@payloadcms/richtext-lexical 3.0.0-canary.a192632 → 3.0.0-canary.a5aaf21

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.js

@@ -1,25 +1,26 @@
 import { convertSlateNodesToLexical } from '../../index.js';
 export const SlateListItemConverter = {
-    converter ({ childIndex, converters, slateNode }) {
-        return {
-            type: 'listitem',
-            checked: undefined,
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'listitem',
-                slateNodes: slateNode.children
-            }),
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            value: childIndex + 1,
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'li'
-    ]
+  converter({
+    childIndex,
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'listitem',
+      checked: undefined,
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'listitem',
+        slateNodes: slateNode.children
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      value: childIndex + 1,
+      version: 1
+    };
+  },
+  nodeTypes: ['li']
 };
-
 //# sourceMappingURL=converter.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateListItemConverter: SlateNodeConverter = {\n  converter({ childIndex, converters, slateNode }) {\n    return {\n      type: 'listitem',\n      checked: undefined,\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'listitem',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['li'],\n}\n"],"names":["convertSlateNodesToLexical","SlateListItemConverter","converter","childIndex","converters","slateNode","type","checked","undefined","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","value","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,yBAA6C;IACxDC,WAAU,EAAEC,UAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QAC7C,OAAO;YACLC,MAAM;YACNC,SAASC;YACTC,UAAUT,2BAA2B;gBACnCU,sBAAsB;gBACtBN;gBACAO,gBAAgB;gBAChBC,YAAYP,UAAUI,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,OAAOb,aAAa;YACpBc,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateListItemConverter","converter","childIndex","converters","slateNode","type","checked","undefined","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","value","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateListItemConverter: SlateNodeConverter = {\n  converter({ childIndex, converters, slateNode }) {\n    return {\n      type: 'listitem',\n      checked: undefined,\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'listitem',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['li'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,sBAAA,GAA6C;EACxDC,UAAU;IAAEC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IAC7C,OAAO;MACLC,IAAA,EAAM;MACNC,OAAA,EAASC,SAAA;MACTC,QAAA,EAAUT,0BAAA,CAA2B;QACnCU,oBAAA,EAAsB;QACtBN,UAAA;QACAO,cAAA,EAAgB;QAChBC,UAAA,EAAYP,SAAA,CAAUI;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,KAAA,EAAOb,UAAA,GAAa;MACpBc,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.js

@@ -1,26 +1,26 @@
 import { convertSlateNodesToLexical } from '../../index.js';
 export const SlateOrderedListConverter = {
-    converter ({ converters, slateNode }) {
-        return {
-            type: 'list',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'list',
-                slateNodes: slateNode.children
-            }),
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            listType: 'number',
-            start: 1,
-            tag: 'ol',
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'ol'
-    ]
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'list',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'list',
+        slateNodes: slateNode.children
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      listType: 'number',
+      start: 1,
+      tag: 'ol',
+      version: 1
+    };
+  },
+  nodeTypes: ['ol']
 };
-
 //# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateOrderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'number',\n      start: 1,\n      tag: 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ol'],\n}\n"],"names":["convertSlateNodesToLexical","SlateOrderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,4BAAgD;IAC3DC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,UAAU;YACVC,OAAO;YACPC,KAAK;YACLC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateOrderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateOrderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'number',\n      start: 1,\n      tag: 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ol'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,yBAAA,GAAgD;EAC3DC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,QAAA,EAAU;MACVC,KAAA,EAAO;MACPC,GAAA,EAAK;MACLC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.js

@@ -1,16 +1,15 @@
 export const SlateRelationshipConverter = {
-    converter ({ slateNode }) {
-        return {
-            type: 'relationship',
-            format: '',
-            relationTo: slateNode.relationTo,
-            value: slateNode?.value?.id || '',
-            version: 2
-        };
-    },
-    nodeTypes: [
-        'relationship'
-    ]
+  converter({
+    slateNode
+  }) {
+    return {
+      type: 'relationship',
+      format: '',
+      relationTo: slateNode.relationTo,
+      value: slateNode?.value?.id || '',
+      version: 2
+    };
+  },
+  nodeTypes: ['relationship']
 };
-
 //# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"sourcesContent":["import type { SerializedRelationshipNode } from '../../../../../relationship/server/nodes/RelationshipNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateRelationshipConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'relationship',\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode?.value?.id || '',\n      version: 2,\n    } as const as SerializedRelationshipNode\n  },\n  nodeTypes: ['relationship'],\n}\n"],"names":["SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"mappings":"AAGA,OAAO,MAAMA,6BAAiD;IAC5DC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;YACRC,YAAYH,UAAUG,UAAU;YAChCC,OAAOJ,WAAWI,OAAOC,MAAM;YAC/BC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAe;AAC7B,EAAC"}
+{"version":3,"file":"converter.js","names":["SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"sourcesContent":["import type { SerializedRelationshipNode } from '../../../../../relationship/server/nodes/RelationshipNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateRelationshipConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'relationship',\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode?.value?.id || '',\n      version: 2,\n    } as const as SerializedRelationshipNode\n  },\n  nodeTypes: ['relationship'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,0BAAA,GAAiD;EAC5DC,UAAU;IAAEC;EAAS,CAAE;IACrB,OAAO;MACLC,IAAA,EAAM;MACNC,MAAA,EAAQ;MACRC,UAAA,EAAYH,SAAA,CAAUG,UAAU;MAChCC,KAAA,EAAOJ,SAAA,EAAWI,KAAA,EAAOC,EAAA,IAAM;MAC/BC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

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

@@ -1,27 +1,27 @@
 import { convertSlateNodesToLexical } from '../../index.js';
 export const SlateUnknownConverter = {
-    converter ({ converters, slateNode }) {
-        return {
-            type: 'unknownConverted',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'unknownConverted',
-                slateNodes: slateNode.children
-            }),
-            data: {
-                nodeData: slateNode,
-                nodeType: slateNode.type
-            },
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'unknown'
-    ]
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'unknownConverted',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'unknownConverted',
+        slateNodes: slateNode.children
+      }),
+      data: {
+        nodeData: slateNode,
+        nodeType: slateNode.type
+      },
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    };
+  },
+  nodeTypes: ['unknown']
 };
-
 //# sourceMappingURL=converter.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnknownConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'unknownConverted',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'unknownConverted',\n        slateNodes: slateNode.children,\n      }),\n      data: {\n        nodeData: slateNode,\n        nodeType: slateNode.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":["convertSlateNodesToLexical","SlateUnknownConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,wBAA4C;IACvDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,MAAM;gBACJC,UAAUP;gBACVQ,UAAUR,UAAUC,IAAI;YAC1B;YACAQ,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAU;AACxB,EAAC"}
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateUnknownConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnknownConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'unknownConverted',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'unknownConverted',\n        slateNodes: slateNode.children,\n      }),\n      data: {\n        nodeData: slateNode,\n        nodeType: slateNode.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,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,qBAAA,GAA4C;EACvDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,IAAA,EAAM;QACJC,QAAA,EAAUP,SAAA;QACVQ,QAAA,EAAUR,SAAA,CAAUC;MACtB;MACAQ,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/unorderedList/converter.js

@@ -1,26 +1,26 @@
 import { convertSlateNodesToLexical } from '../../index.js';
 export const SlateUnorderedListConverter = {
-    converter ({ converters, slateNode }) {
-        return {
-            type: 'list',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'list',
-                slateNodes: slateNode.children
-            }),
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            listType: 'bullet',
-            start: 1,
-            tag: 'ul',
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'ul'
-    ]
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'list',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'list',
+        slateNodes: slateNode.children
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      listType: 'bullet',
+      start: 1,
+      tag: 'ul',
+      version: 1
+    };
+  },
+  nodeTypes: ['ul']
 };
-
 //# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/unorderedList/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnorderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'bullet',\n      start: 1,\n      tag: 'ul',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ul'],\n}\n"],"names":["convertSlateNodesToLexical","SlateUnorderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,8BAAkD;IAC7DC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,UAAU;YACVC,OAAO;YACPC,KAAK;YACLC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateUnorderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnorderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'bullet',\n      start: 1,\n      tag: 'ul',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ul'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,2BAAA,GAAkD;EAC7DC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,QAAA,EAAU;MACVC,KAAA,EAAO;MACPC,GAAA,EAAK;MACLC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

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

@@ -1,19 +1,18 @@
 export const SlateUploadConverter = {
-    converter ({ slateNode }) {
-        return {
-            type: 'upload',
-            fields: {
-                ...slateNode.fields
-            },
-            format: '',
-            relationTo: slateNode.relationTo,
-            value: slateNode.value?.id || '',
-            version: 2
-        };
-    },
-    nodeTypes: [
-        'upload'
-    ]
+  converter({
+    slateNode
+  }) {
+    return {
+      type: 'upload',
+      fields: {
+        ...slateNode.fields
+      },
+      format: '',
+      relationTo: slateNode.relationTo,
+      value: slateNode.value?.id || '',
+      version: 2
+    };
+  },
+  nodeTypes: ['upload']
 };
-
 //# sourceMappingURL=converter.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["import type { SerializedUploadNode } from '../../../../../upload/server/nodes/UploadNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateUploadConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'upload',\n      fields: {\n        ...slateNode.fields,\n      },\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["SlateUploadConverter","converter","slateNode","type","fields","format","relationTo","value","id","version","nodeTypes"],"mappings":"AAGA,OAAO,MAAMA,uBAA2C;IACtDC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;gBACN,GAAGF,UAAUE,MAAM;YACrB;YACAC,QAAQ;YACRC,YAAYJ,UAAUI,UAAU;YAChCC,OAAOL,UAAUK,KAAK,EAAEC,MAAM;YAC9BC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}
+{"version":3,"file":"converter.js","names":["SlateUploadConverter","converter","slateNode","type","fields","format","relationTo","value","id","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["import type { SerializedUploadNode } from '../../../../../upload/server/nodes/UploadNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateUploadConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'upload',\n      fields: {\n        ...slateNode.fields,\n      },\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,oBAAA,GAA2C;EACtDC,UAAU;IAAEC;EAAS,CAAE;IACrB,OAAO;MACLC,IAAA,EAAM;MACNC,MAAA,EAAQ;QACN,GAAGF,SAAA,CAAUE;MACf;MACAC,MAAA,EAAQ;MACRC,UAAA,EAAYJ,SAAA,CAAUI,UAAU;MAChCC,KAAA,EAAOL,SAAA,CAAUK,KAAK,EAAEC,EAAA,IAAM;MAC9BC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

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

@@ -8,17 +8,5 @@ import { SlateRelationshipConverter } from './converters/relationship/converter.
 import { SlateUnknownConverter } from './converters/unknown/converter.js';
 import { SlateUnorderedListConverter } from './converters/unorderedList/converter.js';
 import { SlateUploadConverter } from './converters/upload/converter.js';
-export const defaultSlateConverters = [
-    SlateBlockquoteConverter,
-    SlateHeadingConverter,
-    SlateIndentConverter,
-    SlateLinkConverter,
-    SlateListItemConverter,
-    SlateOrderedListConverter,
-    SlateRelationshipConverter,
-    SlateUnorderedListConverter,
-    SlateUploadConverter,
-    SlateUnknownConverter
-];
-
+export const defaultSlateConverters = [SlateBlockquoteConverter, SlateHeadingConverter, SlateIndentConverter, SlateLinkConverter, SlateListItemConverter, SlateOrderedListConverter, SlateRelationshipConverter, SlateUnorderedListConverter, SlateUploadConverter, SlateUnknownConverter];
 //# sourceMappingURL=defaultConverters.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/slateToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { SlateNodeConverter } from './types.js'\n\nimport { SlateBlockquoteConverter } from './converters/blockquote/converter.js'\nimport { SlateHeadingConverter } from './converters/heading/converter.js'\nimport { SlateIndentConverter } from './converters/indent/converter.js'\nimport { SlateLinkConverter } from './converters/link/converter.js'\nimport { SlateListItemConverter } from './converters/listItem/converter.js'\nimport { SlateOrderedListConverter } from './converters/orderedList/converter.js'\nimport { SlateRelationshipConverter } from './converters/relationship/converter.js'\nimport { SlateUnknownConverter } from './converters/unknown/converter.js'\nimport { SlateUnorderedListConverter } from './converters/unorderedList/converter.js'\nimport { SlateUploadConverter } from './converters/upload/converter.js'\n\nexport const defaultSlateConverters: SlateNodeConverter[] = [\n  SlateBlockquoteConverter,\n  SlateHeadingConverter,\n  SlateIndentConverter,\n  SlateLinkConverter,\n  SlateListItemConverter,\n  SlateOrderedListConverter,\n  SlateRelationshipConverter,\n  SlateUnorderedListConverter,\n  SlateUploadConverter,\n  SlateUnknownConverter,\n]\n"],"names":["SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters"],"mappings":"AAEA,SAASA,wBAAwB,QAAQ,uCAAsC;AAC/E,SAASC,qBAAqB,QAAQ,oCAAmC;AACzE,SAASC,oBAAoB,QAAQ,mCAAkC;AACvE,SAASC,kBAAkB,QAAQ,iCAAgC;AACnE,SAASC,sBAAsB,QAAQ,qCAAoC;AAC3E,SAASC,yBAAyB,QAAQ,wCAAuC;AACjF,SAASC,0BAA0B,QAAQ,yCAAwC;AACnF,SAASC,qBAAqB,QAAQ,oCAAmC;AACzE,SAASC,2BAA2B,QAAQ,0CAAyC;AACrF,SAASC,oBAAoB,QAAQ,mCAAkC;AAEvE,OAAO,MAAMC,yBAA+C;IAC1DV;IACAC;IACAC;IACAC;IACAC;IACAC;IACAC;IACAE;IACAC;IACAF;CACD,CAAA"}
+{"version":3,"file":"defaultConverters.js","names":["SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters"],"sources":["../../../../../src/features/migrations/slateToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { SlateNodeConverter } from './types.js'\n\nimport { SlateBlockquoteConverter } from './converters/blockquote/converter.js'\nimport { SlateHeadingConverter } from './converters/heading/converter.js'\nimport { SlateIndentConverter } from './converters/indent/converter.js'\nimport { SlateLinkConverter } from './converters/link/converter.js'\nimport { SlateListItemConverter } from './converters/listItem/converter.js'\nimport { SlateOrderedListConverter } from './converters/orderedList/converter.js'\nimport { SlateRelationshipConverter } from './converters/relationship/converter.js'\nimport { SlateUnknownConverter } from './converters/unknown/converter.js'\nimport { SlateUnorderedListConverter } from './converters/unorderedList/converter.js'\nimport { SlateUploadConverter } from './converters/upload/converter.js'\n\nexport const defaultSlateConverters: SlateNodeConverter[] = [\n  SlateBlockquoteConverter,\n  SlateHeadingConverter,\n  SlateIndentConverter,\n  SlateLinkConverter,\n  SlateListItemConverter,\n  SlateOrderedListConverter,\n  SlateRelationshipConverter,\n  SlateUnorderedListConverter,\n  SlateUploadConverter,\n  SlateUnknownConverter,\n]\n"],"mappings":"AAEA,SAASA,wBAAwB,QAAQ;AACzC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,kBAAkB,QAAQ;AACnC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,yBAAyB,QAAQ;AAC1C,SAASC,0BAA0B,QAAQ;AAC3C,SAASC,qBAAqB,QAAQ;AACtC,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,sBAAA,GAA+C,CAC1DV,wBAAA,EACAC,qBAAA,EACAC,oBAAA,EACAC,kBAAA,EACAC,sBAAA,EACAC,yBAAA,EACAC,0BAAA,EACAE,2BAAA,EACAC,oBAAA,EACAF,qBAAA,CACD","ignoreList":[]}

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

@@ -1,109 +1,116 @@
 import { NodeFormat } from '../../../../lexical/utils/nodeFormat.js';
-export function convertSlateToLexical({ converters, slateData }) {
-    return {
-        root: {
-            type: 'root',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: true,
-                converters,
-                parentNodeType: 'root',
-                slateNodes: slateData
-            }),
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            version: 1
-        }
-    };
+export function convertSlateToLexical({
+  converters,
+  slateData
+}) {
+  return {
+    root: {
+      type: 'root',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: true,
+        converters,
+        parentNodeType: 'root',
+        slateNodes: slateData
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    }
+  };
 }
-export function convertSlateNodesToLexical({ canContainParagraphs, converters, parentNodeType, slateNodes }) {
-    if (!converters?.length) {
-        return [];
+export function convertSlateNodesToLexical({
+  canContainParagraphs,
+  converters,
+  parentNodeType,
+  slateNodes
+}) {
+  if (!converters?.length || !slateNodes?.length) {
+    return [];
+  }
+  const unknownConverter = converters.find(converter => converter.nodeTypes.includes('unknown'));
+  return slateNodes.map((slateNode, i) => {
+    if (!('type' in slateNode)) {
+      if (canContainParagraphs) {
+        // This is a paragraph node. They do not have a type property in Slate
+        return convertParagraphNode(converters, slateNode);
+      } else {
+        // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs
+        return convertTextNode(slateNode);
+      }
+    }
+    if (slateNode.type === 'p') {
+      return convertParagraphNode(converters, slateNode);
+    }
+    const converter = converters.find(converter => converter.nodeTypes.includes(slateNode.type));
+    if (converter) {
+      return converter.converter({
+        childIndex: i,
+        converters,
+        parentNodeType,
+        slateNode
+      });
     }
-    const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
-    return slateNodes.map((slateNode, i)=>{
-        if (!('type' in slateNode)) {
-            if (canContainParagraphs) {
-                // This is a paragraph node. They do not have a type property in Slate
-                return convertParagraphNode(converters, slateNode);
-            } else {
-                // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs
-                return convertTextNode(slateNode);
-            }
-        }
-        if (slateNode.type === 'p') {
-            return convertParagraphNode(converters, slateNode);
-        }
-        const converter = converters.find((converter)=>converter.nodeTypes.includes(slateNode.type));
-        if (converter) {
-            return converter.converter({
-                childIndex: i,
-                converters,
-                parentNodeType,
-                slateNode
-            });
-        }
-        console.warn('slateToLexical > No converter found for node type: ' + slateNode.type);
-        return unknownConverter?.converter({
-            childIndex: i,
-            converters,
-            parentNodeType,
-            slateNode
-        });
-    }) || [];
+    console.warn('slateToLexical > No converter found for node type: ' + slateNode.type);
+    return unknownConverter?.converter({
+      childIndex: i,
+      converters,
+      parentNodeType,
+      slateNode
+    });
+  }) || [];
 }
 export function convertParagraphNode(converters, node) {
-    return {
-        type: 'paragraph',
-        children: convertSlateNodesToLexical({
-            canContainParagraphs: false,
-            converters,
-            parentNodeType: 'paragraph',
-            slateNodes: node.children || []
-        }),
-        direction: 'ltr',
-        format: '',
-        indent: 0,
-        textFormat: 0,
-        textStyle: '',
-        version: 1
-    };
+  return {
+    type: 'paragraph',
+    children: convertSlateNodesToLexical({
+      canContainParagraphs: false,
+      converters,
+      parentNodeType: 'paragraph',
+      slateNodes: node.children || []
+    }),
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    textFormat: 0,
+    textStyle: '',
+    version: 1
+  };
 }
 export function convertTextNode(node) {
-    return {
-        type: 'text',
-        detail: 0,
-        format: convertNodeToFormat(node),
-        mode: 'normal',
-        style: '',
-        text: node.text,
-        version: 1
-    };
+  return {
+    type: 'text',
+    detail: 0,
+    format: convertNodeToFormat(node),
+    mode: 'normal',
+    style: '',
+    text: node.text,
+    version: 1
+  };
 }
 export function convertNodeToFormat(node) {
-    let format = 0;
-    if (node.bold) {
-        format = format | NodeFormat.IS_BOLD;
-    }
-    if (node.italic) {
-        format = format | NodeFormat.IS_ITALIC;
-    }
-    if (node.strikethrough) {
-        format = format | NodeFormat.IS_STRIKETHROUGH;
-    }
-    if (node.underline) {
-        format = format | NodeFormat.IS_UNDERLINE;
-    }
-    if (node.subscript) {
-        format = format | NodeFormat.IS_SUBSCRIPT;
-    }
-    if (node.superscript) {
-        format = format | NodeFormat.IS_SUPERSCRIPT;
-    }
-    if (node.code) {
-        format = format | NodeFormat.IS_CODE;
-    }
-    return format;
+  let format = 0;
+  if (node.bold) {
+    format = format | NodeFormat.IS_BOLD;
+  }
+  if (node.italic) {
+    format = format | NodeFormat.IS_ITALIC;
+  }
+  if (node.strikethrough) {
+    format = format | NodeFormat.IS_STRIKETHROUGH;
+  }
+  if (node.underline) {
+    format = format | NodeFormat.IS_UNDERLINE;
+  }
+  if (node.subscript) {
+    format = format | NodeFormat.IS_SUBSCRIPT;
+  }
+  if (node.superscript) {
+    format = format | NodeFormat.IS_SUPERSCRIPT;
+  }
+  if (node.code) {
+    format = format | NodeFormat.IS_CODE;
+  }
+  return format;
 }
-
 //# sourceMappingURL=index.js.map