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

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const _ListItemConverter: LexicalPluginNodeConverter = {\n  converter({ childIndex, converters, lexicalPluginNode }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'listitem',\n      checked: undefined,\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'listitem',\n      }),\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['listitem'],\n}\n"],"names":["convertLexicalPluginNodesToLexical","_ListItemConverter","converter","childIndex","converters","lexicalPluginNode","type","checked","undefined","children","lexicalPluginNodes","parentNodeType","value","version","nodeTypes"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,qBAAiD;IAC5DC,WAAU,EAAEC,UAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAE;QACrD,OAAO;YACL,GAAGA,iBAAiB;YACpBC,MAAM;YACNC,SAASC;YACTC,UAAUT,mCAAmC;gBAC3CI;gBACAM,oBAAoBL,kBAAkBI,QAAQ;gBAC9CE,gBAAgB;YAClB;YACAC,OAAOT,aAAa;YACpBU,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAW;AACzB,EAAC"}
+{"version":3,"file":"converter.js","names":["convertLexicalPluginNodesToLexical","ListItemConverter","converter","childIndex","converters","lexicalPluginNode","quiet","type","checked","undefined","children","lexicalPluginNodes","parentNodeType","value","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const ListItemConverter: LexicalPluginNodeConverter = {\n  converter({ childIndex, converters, lexicalPluginNode, quiet }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'listitem',\n      checked: undefined,\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'listitem',\n        quiet,\n      }),\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['listitem'],\n}\n"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ;AAEnD,OAAO,MAAMC,iBAAA,GAAgD;EAC3DC,UAAU;IAAEC,UAAU;IAAEC,UAAU;IAAEC,iBAAiB;IAAEC;EAAK,CAAE;IAC5D,OAAO;MACL,GAAGD,iBAAiB;MACpBE,IAAA,EAAM;MACNC,OAAA,EAASC,SAAA;MACTC,QAAA,EAAUV,kCAAA,CAAmC;QAC3CI,UAAA;QACAO,kBAAA,EAAoBN,iBAAA,CAAkBK,QAAQ;QAC9CE,cAAA,EAAgB;QAChBN;MACF;MACAO,KAAA,EAAOV,UAAA,GAAa;MACpBW,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.d.ts

@@ -1,3 +1,3 @@
 import type { LexicalPluginNodeConverter } from '../../types.js';
-export declare const _QuoteConverter: LexicalPluginNodeConverter;
+export declare const QuoteConverter: LexicalPluginNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,eAAe,EAAE,0BAc7B,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,cAAc,EAAE,0BAe5B,CAAA"}

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

@@ -1,20 +1,22 @@
 import { convertLexicalPluginNodesToLexical } from '../../index.js';
-export const _QuoteConverter = {
-    converter ({ converters, lexicalPluginNode }) {
-        return {
-            ...lexicalPluginNode,
-            type: 'quote',
-            children: convertLexicalPluginNodesToLexical({
-                converters,
-                lexicalPluginNodes: lexicalPluginNode.children,
-                parentNodeType: 'quote'
-            }),
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'quote'
-    ]
+export const QuoteConverter = {
+  converter({
+    converters,
+    lexicalPluginNode,
+    quiet
+  }) {
+    return {
+      ...lexicalPluginNode,
+      type: 'quote',
+      children: convertLexicalPluginNodesToLexical({
+        converters,
+        lexicalPluginNodes: lexicalPluginNode.children,
+        parentNodeType: 'quote',
+        quiet
+      }),
+      version: 1
+    };
+  },
+  nodeTypes: ['quote']
 };
-
 //# sourceMappingURL=converter.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../blockquote/feature.server.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const _QuoteConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'quote',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'quote',\n      }),\n      version: 1,\n    } as const as SerializedQuoteNode\n  },\n  nodeTypes: ['quote'],\n}\n"],"names":["convertLexicalPluginNodesToLexical","_QuoteConverter","converter","converters","lexicalPluginNode","type","children","lexicalPluginNodes","parentNodeType","version","nodeTypes"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,kBAA8C;IACzDC,WAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAE;QACzC,OAAO;YACL,GAAGA,iBAAiB;YACpBC,MAAM;YACNC,UAAUN,mCAAmC;gBAC3CG;gBACAI,oBAAoBH,kBAAkBE,QAAQ;gBAC9CE,gBAAgB;YAClB;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAQ;AACtB,EAAC"}
+{"version":3,"file":"converter.js","names":["convertLexicalPluginNodesToLexical","QuoteConverter","converter","converters","lexicalPluginNode","quiet","type","children","lexicalPluginNodes","parentNodeType","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../blockquote/server/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const QuoteConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode, quiet }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'quote',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'quote',\n        quiet,\n      }),\n      version: 1,\n    } as const as SerializedQuoteNode\n  },\n  nodeTypes: ['quote'],\n}\n"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ;AAEnD,OAAO,MAAMC,cAAA,GAA6C;EACxDC,UAAU;IAAEC,UAAU;IAAEC,iBAAiB;IAAEC;EAAK,CAAE;IAChD,OAAO;MACL,GAAGD,iBAAiB;MACpBE,IAAA,EAAM;MACNC,QAAA,EAAUP,kCAAA,CAAmC;QAC3CG,UAAA;QACAK,kBAAA,EAAoBJ,iBAAA,CAAkBG,QAAQ;QAC9CE,cAAA,EAAgB;QAChBJ;MACF;MACAK,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.d.ts

@@ -1,3 +1,3 @@
 import type { LexicalPluginNodeConverter } from '../../types.js';
-export declare const _UnknownConverter: LexicalPluginNodeConverter;
+export declare const UnknownConverter: LexicalPluginNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,iBAAiB,EAAE,0BAoB/B,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,gBAAgB,EAAE,0BAqB9B,CAAA"}

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

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

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

@@ -1 +1 @@
-{"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 }) {\n    return {\n      type: 'unknownConverted',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'unknownConverted',\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","type","children","lexicalPluginNodes","parentNodeType","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,oBAAgD;IAC3DC,WAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAE;QACzC,OAAO;YACLC,MAAM;YACNC,UAAUN,mCAAmC;gBAC3CG;gBACAI,oBAAoBH,kBAAkBE,QAAQ;gBAC9CE,gBAAgB;YAClB;YACAC,MAAM;gBACJC,UAAUN;gBACVO,UAAUP,kBAAkBC,IAAI;YAClC;YACAO,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAU;AACxB,EAAC"}
+{"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":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.d.ts

@@ -1,3 +1,3 @@
 import type { LexicalPluginNodeConverter } from '../../types.js';
-export declare const _UploadConverter: LexicalPluginNodeConverter;
+export declare const UploadConverter: LexicalPluginNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,eAAO,MAAM,gBAAgB,EAAE,0BAkB9B,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,eAAO,MAAM,eAAe,EAAE,0BAkB7B,CAAA"}

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

@@ -1,23 +1,22 @@
-/* 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,"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedUploadNode } from '../../../../../upload/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,mBAA+C;IAC1DC,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"}
+{"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":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/defaultConverters.d.ts

@@ -1,3 +1,3 @@
-import type { LexicalPluginNodeConverterProvider } from './types.js';
-export declare const defaultConverters: LexicalPluginNodeConverterProvider[];
+import type { LexicalPluginNodeConverter } from './types.js';
+export declare const defaultConverters: LexicalPluginNodeConverter[];
 //# sourceMappingURL=defaultConverters.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/converter/defaultConverters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,YAAY,CAAA;AAUpE,eAAO,MAAM,iBAAiB,EAAE,kCAAkC,EAQjE,CAAA"}
+{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAU5D,eAAO,MAAM,iBAAiB,EAAE,0BAA0B,EAQzD,CAAA"}

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

@@ -1,18 +1,9 @@
-import { HeadingConverter } from './converters/heading/index.js';
-import { LinkConverter } from './converters/link/index.js';
-import { ListConverter } from './converters/list/index.js';
-import { ListItemConverter } from './converters/listItem/index.js';
-import { QuoteConverter } from './converters/quote/index.js';
-import { UnknownConverter } from './converters/unknown/index.js';
-import { UploadConverter } from './converters/upload/index.js';
-export const defaultConverters = [
-    HeadingConverter,
-    LinkConverter,
-    ListConverter,
-    ListItemConverter,
-    QuoteConverter,
-    UnknownConverter,
-    UploadConverter
-];
-
+import { HeadingConverter } from './converters/heading/converter.js';
+import { LinkConverter } from './converters/link/converter.js';
+import { ListConverter } from './converters/list/converter.js';
+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];
 //# sourceMappingURL=defaultConverters.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from './types.js'\n\nimport { HeadingConverter } from './converters/heading/index.js'\nimport { LinkConverter } from './converters/link/index.js'\nimport { ListConverter } from './converters/list/index.js'\nimport { ListItemConverter } from './converters/listItem/index.js'\nimport { QuoteConverter } from './converters/quote/index.js'\nimport { UnknownConverter } from './converters/unknown/index.js'\nimport { UploadConverter } from './converters/upload/index.js'\n\nexport const defaultConverters: LexicalPluginNodeConverterProvider[] = [\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,gCAA+B;AAChE,SAASC,aAAa,QAAQ,6BAA4B;AAC1D,SAASC,aAAa,QAAQ,6BAA4B;AAC1D,SAASC,iBAAiB,QAAQ,iCAAgC;AAClE,SAASC,cAAc,QAAQ,8BAA6B;AAC5D,SAASC,gBAAgB,QAAQ,gCAA+B;AAChE,SAASC,eAAe,QAAQ,+BAA8B;AAE9D,OAAO,MAAMC,oBAA0D;IACrEP;IACAC;IACAC;IACAC;IACAC;IACAC;IACAC;CACD,CAAA"}
+{"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":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/index.d.ts

@@ -1,17 +1,19 @@
 import type { SerializedEditorState, SerializedLexicalNode, SerializedParagraphNode, SerializedTextNode } from 'lexical';
 import type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './types.js';
-export declare function convertLexicalPluginToLexical({ converters, lexicalPluginData, }: {
+export declare function convertLexicalPluginToLexical({ converters, lexicalPluginData, quiet, }: {
     converters: LexicalPluginNodeConverter[];
     lexicalPluginData: PayloadPluginLexicalData;
+    quiet?: boolean;
 }): SerializedEditorState;
-export declare function convertLexicalPluginNodesToLexical({ converters, lexicalPluginNodes, parentNodeType, }: {
+export declare function convertLexicalPluginNodesToLexical({ converters, lexicalPluginNodes, parentNodeType, quiet, }: {
     converters: LexicalPluginNodeConverter[];
     lexicalPluginNodes: SerializedLexicalNode[] | undefined;
     /**
      * Type of the parent lexical node (not the type of the original, parent payload-plugin-lexical type)
      */
     parentNodeType: string;
+    quiet?: boolean;
 }): SerializedLexicalNode[];
-export declare function convertParagraphNode(converters: LexicalPluginNodeConverter[], node: SerializedLexicalNode): SerializedParagraphNode;
+export declare function convertParagraphNode(converters: LexicalPluginNodeConverter[], node: SerializedLexicalNode, quiet?: boolean): SerializedParagraphNode;
 export declare function convertTextNode(node: SerializedLexicalNode): SerializedTextNode;
 //# sourceMappingURL=index.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/converter/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAEtF,wBAAgB,6BAA6B,CAAC,EAC5C,UAAU,EACV,iBAAiB,GAClB,EAAE;IACD,UAAU,EAAE,0BAA0B,EAAE,CAAA;IACxC,iBAAiB,EAAE,wBAAwB,CAAA;CAC5C,GAAG,qBAAqB,CAexB;AAED,wBAAgB,kCAAkC,CAAC,EACjD,UAAU,EACV,kBAAkB,EAClB,cAAc,GACf,EAAE;IACD,UAAU,EAAE,0BAA0B,EAAE,CAAA;IACxC,kBAAkB,EAAE,qBAAqB,EAAE,GAAG,SAAS,CAAA;IACvD;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;CACvB,GAAG,qBAAqB,EAAE,CAiC1B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,0BAA0B,EAAE,EACxC,IAAI,EAAE,qBAAqB,GAC1B,uBAAuB,CAYzB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,qBAAqB,GAAG,kBAAkB,CAE/E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAEtF,wBAAgB,6BAA6B,CAAC,EAC5C,UAAU,EACV,iBAAiB,EACjB,KAAK,GACN,EAAE;IACD,UAAU,EAAE,0BAA0B,EAAE,CAAA;IACxC,iBAAiB,EAAE,wBAAwB,CAAA;IAC3C,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,GAAG,qBAAqB,CAgBxB;AAED,wBAAgB,kCAAkC,CAAC,EACjD,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,KAAK,GACN,EAAE;IACD,UAAU,EAAE,0BAA0B,EAAE,CAAA;IACxC,kBAAkB,EAAE,qBAAqB,EAAE,GAAG,SAAS,CAAA;IACvD;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,GAAG,qBAAqB,EAAE,CA4C1B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,0BAA0B,EAAE,EACxC,IAAI,EAAE,qBAAqB,EAC3B,KAAK,CAAC,EAAE,OAAO,GACd,uBAAuB,CAazB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,qBAAqB,GAAG,kBAAkB,CAE/E"}

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

@@ -1,63 +1,78 @@
-export function convertLexicalPluginToLexical({ converters, lexicalPluginData }) {
-    return {
-        root: {
-            type: 'root',
-            children: convertLexicalPluginNodesToLexical({
-                converters,
-                lexicalPluginNodes: lexicalPluginData?.jsonContent?.root?.children || [],
-                parentNodeType: 'root'
-            }),
-            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 }) {
-    if (!lexicalPluginNodes?.length) {
-        return [];
+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);
     }
-    const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
-    return lexicalPluginNodes.map((lexicalPluginNode, i)=>{
-        if (lexicalPluginNode.type === 'paragraph') {
-            return convertParagraphNode(converters, lexicalPluginNode);
-        }
-        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
-            });
-        }
-        console.warn('lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type);
-        return unknownConverter?.converter({
-            childIndex: i,
-            converters,
-            lexicalPluginNode,
-            parentNodeType
-        });
-    }) || [];
+    return unknownConverter?.converter({
+      childIndex: i,
+      converters,
+      lexicalPluginNode,
+      parentNodeType,
+      quiet
+    });
+  }) || [];
 }
-export function convertParagraphNode(converters, node) {
-    return {
-        ...node,
-        type: 'paragraph',
-        children: convertLexicalPluginNodesToLexical({
-            converters,
-            lexicalPluginNodes: node.children || [],
-            parentNodeType: 'paragraph'
-        }),
-        version: 1
-    };
+export function convertParagraphNode(converters, node, quiet) {
+  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,"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}: {\n  converters: LexicalPluginNodeConverter[]\n  lexicalPluginData: PayloadPluginLexicalData\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginData?.jsonContent?.root?.children || [],\n        parentNodeType: 'root',\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}: {\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}): SerializedLexicalNode[] {\n  if (!lexicalPluginNodes?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  return (\n    lexicalPluginNodes.map((lexicalPluginNode, i) => {\n      if (lexicalPluginNode.type === 'paragraph') {\n        return convertParagraphNode(converters, lexicalPluginNode)\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({ childIndex: i, converters, lexicalPluginNode, parentNodeType })\n      }\n\n      console.warn(\n        'lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type,\n      )\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        lexicalPluginNode,\n        parentNodeType,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: LexicalPluginNodeConverter[],\n  node: SerializedLexicalNode,\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    }),\n    version: 1,\n  } as SerializedParagraphNode\n}\nexport function convertTextNode(node: SerializedLexicalNode): SerializedTextNode {\n  return node as SerializedTextNode\n}\n"],"names":["convertLexicalPluginToLexical","converters","lexicalPluginData","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,EAIlB;IACC,OAAO;QACLC,MAAM;YACJC,MAAM;YACNC,UAAUC,mCAAmC;gBAC3CL;gBACAM,oBAAoBL,mBAAmBM,aAAaL,MAAME,YAAY,EAAE;gBACxEI,gBAAgB;YAClB;YACAC,WAAWR,mBAAmBM,aAAaL,MAAMO,aAAa;YAC9DC,QAAQT,mBAAmBM,aAAaL,MAAMQ,UAAU;YACxDC,QAAQV,mBAAmBM,aAAaL,MAAMS,UAAU;YACxDC,SAAS;QACX;IACF;AACF;AAEA,OAAO,SAASP,mCAAmC,EACjDL,UAAU,EACVM,kBAAkB,EAClBE,cAAc,EAQf;IACC,IAAI,CAACF,oBAAoBO,QAAQ;QAC/B,OAAO,EAAE;IACX;IACA,MAAMC,mBAAmBd,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IACrF,OACEZ,mBAAmBa,GAAG,CAAC,CAACC,mBAAmBC;QACzC,IAAID,kBAAkBjB,IAAI,KAAK,aAAa;YAC1C,OAAOmB,qBAAqBtB,YAAYoB;QAC1C;QACA,IAAIA,kBAAkBjB,IAAI,KAAK,UAAU,CAACiB,kBAAkBjB,IAAI,EAAE;YAChE,OAAOoB,gBAAgBH;QACzB;QAEA,MAAMJ,YAAYhB,WAAWe,IAAI,CAAC,CAACC,YACjCA,UAAUC,SAAS,CAACC,QAAQ,CAACE,kBAAkBjB,IAAI;QAGrD,IAAIa,WAAW;YACb,OAAOA,UAAUA,SAAS,CAAC;gBAAEQ,YAAYH;gBAAGrB;gBAAYoB;gBAAmBZ;YAAe;QAC5F;QAEAiB,QAAQC,IAAI,CACV,gEAAgEN,kBAAkBjB,IAAI;QAExF,OAAOW,kBAAkBE,UAAU;YACjCQ,YAAYH;YACZrB;YACAoB;YACAZ;QACF;IACF,MAAM,EAAE;AAEZ;AAEA,OAAO,SAASc,qBACdtB,UAAwC,EACxC2B,IAA2B;IAE3B,OAAO;QACL,GAAGA,IAAI;QACPxB,MAAM;QAENC,UAAUC,mCAAmC;YAC3CL;YACAM,oBAAoB,AAACqB,KAAavB,QAAQ,IAAI,EAAE;YAChDI,gBAAgB;QAClB;QACAI,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAA2B;IACzD,OAAOA;AACT"}
+{"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":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/types.d.ts

@@ -1,5 +1,4 @@
 import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-import type React from 'react';
 export type LexicalPluginNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
     converter: ({ childIndex, converters, lexicalPluginNode, parentNodeType, }: {
         childIndex: number;
@@ -8,6 +7,7 @@ export type LexicalPluginNodeConverter<T extends SerializedLexicalNode = Seriali
             children?: SerializedLexicalNode[];
         } & SerializedLexicalNode;
         parentNodeType: string;
+        quiet?: boolean;
     }) => T;
     nodeTypes: string[];
 };
@@ -20,12 +20,4 @@ export type PayloadPluginLexicalData = {
     preview: string;
     words: number;
 };
-export type LexicalPluginNodeConverterClientComponent = React.FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-export type LexicalPluginNodeConverterProvider = {
-    ClientConverter: LexicalPluginNodeConverterClientComponent;
-    converter: LexicalPluginNodeConverter;
-};
 //# sourceMappingURL=types.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/converter/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAC3E,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IAChG,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,GACf,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,0BAA0B,EAAE,CAAA;QACxC,iBAAiB,EAAE;YAAE,QAAQ,CAAC,EAAE,qBAAqB,EAAE,CAAA;SAAE,GAAG,qBAAqB,CAAA;QACjF,cAAc,EAAE,MAAM,CAAA;KACvB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,qBAAqB,CAAA;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,yCAAyC,GAAG,KAAK,CAAC,EAAE,CAAC;IAC/D,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAC,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,eAAe,EAAE,yCAAyC,CAAA;IAC1D,SAAS,EAAE,0BAA0B,CAAA;CACtC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAE3E,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IAChG,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,GACf,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,0BAA0B,EAAE,CAAA;QACxC,iBAAiB,EAAE;YAAE,QAAQ,CAAC,EAAE,qBAAqB,EAAE,CAAA;SAAE,GAAG,qBAAqB,CAAA;QACjF,cAAc,EAAE,MAAM,CAAA;QACtB,KAAK,CAAC,EAAE,OAAO,CAAA;KAChB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,qBAAqB,CAAA;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA"}

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

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

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\nimport type React from 'react'\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  }) => 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\nexport type LexicalPluginNodeConverterClientComponent = React.FC<{\n  componentKey: string\n  featureKey: string\n}>\n\nexport type LexicalPluginNodeConverterProvider = {\n  ClientConverter: LexicalPluginNodeConverterClientComponent\n  converter: LexicalPluginNodeConverter\n}\n"],"names":[],"mappings":"AAiCA,WAGC"}
+{"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":[]}

package/dist/features/migrations/lexicalPluginToLexical/feature.client.d.ts

@@ -1,5 +1,2 @@
-export declare const LexicalPluginToLexicalFeatureClient: import("react").FC<{
-    featureKey: string;
-    order: number;
-}>;
+export declare const LexicalPluginToLexicalFeatureClient: import("../../typesClient.js").FeatureProviderProviderClient<undefined, undefined>;
 //# sourceMappingURL=feature.client.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/feature.client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"names":[],"mappings":"AAQA,eAAO,MAAM,mCAAmC;;;EAoB9C,CAAA"}
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,mCAAmC,oFAI9C,CAAA"}

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

@@ -1,27 +1,10 @@
 'use client';
+
 import { createClientFeature } from '../../../utilities/createClientFeature.js';
-import { convertLexicalPluginToLexical } from './converter/index.js';
 import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
-export const LexicalPluginToLexicalFeatureClient = createClientFeature(({ clientFunctions })=>{
-    const converters = Object.values(clientFunctions);
-    return {
-        hooks: {
-            load ({ incomingEditorState }) {
-                if (!incomingEditorState || !('jsonContent' in incomingEditorState)) {
-                    // incomingEditorState null or not from Lexical Plugin
-                    return incomingEditorState;
-                }
-                // Lexical Plugin => convert to lexical
-                return convertLexicalPluginToLexical({
-                    converters,
-                    lexicalPluginData: incomingEditorState
-                });
-            }
-        },
-        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,"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types.js'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { convertLexicalPluginToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const LexicalPluginToLexicalFeatureClient = createClientFeature(({ clientFunctions }) => {\n  const converters: LexicalPluginNodeConverter[] = Object.values(clientFunctions)\n\n  return {\n    hooks: {\n      load({ incomingEditorState }) {\n        if (!incomingEditorState || !('jsonContent' in incomingEditorState)) {\n          // incomingEditorState null or not from Lexical Plugin\n          return incomingEditorState\n        }\n        // Lexical Plugin => convert to lexical\n\n        return convertLexicalPluginToLexical({\n          converters,\n          lexicalPluginData: incomingEditorState as unknown as PayloadPluginLexicalData,\n        })\n      },\n    },\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"names":["createClientFeature","convertLexicalPluginToLexical","UnknownConvertedNode","LexicalPluginToLexicalFeatureClient","clientFunctions","converters","Object","values","hooks","load","incomingEditorState","lexicalPluginData","nodes"],"mappings":"AAAA;AAIA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,6BAA6B,QAAQ,uBAAsB;AACpE,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,OAAO,MAAMC,sCAAsCH,oBAAoB,CAAC,EAAEI,eAAe,EAAE;IACzF,MAAMC,aAA2CC,OAAOC,MAAM,CAACH;IAE/D,OAAO;QACLI,OAAO;YACLC,MAAK,EAAEC,mBAAmB,EAAE;gBAC1B,IAAI,CAACA,uBAAuB,CAAE,CAAA,iBAAiBA,mBAAkB,GAAI;oBACnE,sDAAsD;oBACtD,OAAOA;gBACT;gBACA,uCAAuC;gBAEvC,OAAOT,8BAA8B;oBACnCI;oBACAM,mBAAmBD;gBACrB;YACF;QACF;QACAE,OAAO;YAACV;SAAqB;IAC/B;AACF,GAAE"}
+{"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":[]}

package/dist/features/migrations/lexicalPluginToLexical/feature.server.d.ts

@@ -1,8 +1,10 @@
-import type { LexicalPluginNodeConverterProvider } from './converter/types.js';
+import type { LexicalPluginNodeConverter } from './converter/types.js';
 export type LexicalPluginToLexicalFeatureProps = {
     converters?: (({ defaultConverters, }: {
-        defaultConverters: LexicalPluginNodeConverterProvider[];
-    }) => LexicalPluginNodeConverterProvider[]) | LexicalPluginNodeConverterProvider[];
+        defaultConverters: LexicalPluginNodeConverter[];
+    }) => LexicalPluginNodeConverter[]) | LexicalPluginNodeConverter[];
+    disableHooks?: boolean;
+    quiet?: boolean;
 };
 export declare const LexicalPluginToLexicalFeature: import("../../typesServer.js").FeatureProviderProviderServer<LexicalPluginToLexicalFeatureProps, LexicalPluginToLexicalFeatureProps, undefined>;
 //# sourceMappingURL=feature.server.d.ts.map