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

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

@@ -1,109 +1,117 @@
 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'));
+  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix
+  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

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/slateToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { SlateNode, SlateNodeConverter } from './types.js'\n\nimport { NodeFormat } from '../../../../lexical/utils/nodeFormat.js'\n\nexport function convertSlateToLexical({\n  converters,\n  slateData,\n}: {\n  converters: SlateNodeConverter[]\n  slateData: SlateNode[]\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: true,\n        converters,\n        parentNodeType: 'root',\n        slateNodes: slateData,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertSlateNodesToLexical({\n  canContainParagraphs,\n  converters,\n  parentNodeType,\n  slateNodes,\n}: {\n  canContainParagraphs: boolean\n  converters: SlateNodeConverter[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent slate type)\n   */\n  parentNodeType: string\n  slateNodes: SlateNode[]\n}): SerializedLexicalNode[] {\n  if (!converters?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  return (\n    slateNodes.map((slateNode, i) => {\n      if (!('type' in slateNode)) {\n        if (canContainParagraphs) {\n          // This is a paragraph node. They do not have a type property in Slate\n          return convertParagraphNode(converters, slateNode)\n        } else {\n          // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs\n          return convertTextNode(slateNode)\n        }\n      }\n      if (slateNode.type === 'p') {\n        return convertParagraphNode(converters, slateNode)\n      }\n\n      const converter = converters.find((converter) => converter.nodeTypes.includes(slateNode.type))\n\n      if (converter) {\n        return converter.converter({ childIndex: i, converters, parentNodeType, slateNode })\n      }\n\n      console.warn('slateToLexical > No converter found for node type: ' + slateNode.type)\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        parentNodeType,\n        slateNode,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: SlateNodeConverter[],\n  node: SlateNode,\n): SerializedParagraphNode {\n  return {\n    type: 'paragraph',\n    children: convertSlateNodesToLexical({\n      canContainParagraphs: false,\n      converters,\n      parentNodeType: 'paragraph',\n      slateNodes: node.children || [],\n    }),\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    textStyle: '',\n    version: 1,\n  }\n}\nexport function convertTextNode(node: SlateNode): SerializedTextNode {\n  return {\n    type: 'text',\n    detail: 0,\n    format: convertNodeToFormat(node),\n    mode: 'normal',\n    style: '',\n    text: node.text,\n    version: 1,\n  }\n}\n\nexport function convertNodeToFormat(node: SlateNode): number {\n  let format = 0\n  if (node.bold) {\n    format = format | NodeFormat.IS_BOLD\n  }\n  if (node.italic) {\n    format = format | NodeFormat.IS_ITALIC\n  }\n  if (node.strikethrough) {\n    format = format | NodeFormat.IS_STRIKETHROUGH\n  }\n  if (node.underline) {\n    format = format | NodeFormat.IS_UNDERLINE\n  }\n  if (node.subscript) {\n    format = format | NodeFormat.IS_SUBSCRIPT\n  }\n  if (node.superscript) {\n    format = format | NodeFormat.IS_SUPERSCRIPT\n  }\n  if (node.code) {\n    format = format | NodeFormat.IS_CODE\n  }\n  return format\n}\n"],"names":["NodeFormat","convertSlateToLexical","converters","slateData","root","type","children","convertSlateNodesToLexical","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","map","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","textFormat","textStyle","detail","convertNodeToFormat","mode","style","text","bold","IS_BOLD","italic","IS_ITALIC","strikethrough","IS_STRIKETHROUGH","underline","IS_UNDERLINE","subscript","IS_SUBSCRIPT","superscript","IS_SUPERSCRIPT","code","IS_CODE"],"mappings":"AASA,SAASA,UAAU,QAAQ,0CAAyC;AAEpE,OAAO,SAASC,sBAAsB,EACpCC,UAAU,EACVC,SAAS,EAIV;IACC,OAAO;QACLC,MAAM;YACJC,MAAM;YACNC,UAAUC,2BAA2B;gBACnCC,sBAAsB;gBACtBN;gBACAO,gBAAgB;gBAChBC,YAAYP;YACd;YACAQ,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;AACF;AAEA,OAAO,SAASP,2BAA2B,EACzCC,oBAAoB,EACpBN,UAAU,EACVO,cAAc,EACdC,UAAU,EASX;IACC,IAAI,CAACR,YAAYa,QAAQ;QACvB,OAAO,EAAE;IACX;IACA,MAAMC,mBAAmBd,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IACrF,OACEV,WAAWW,GAAG,CAAC,CAACC,WAAWC;QACzB,IAAI,CAAE,CAAA,UAAUD,SAAQ,GAAI;YAC1B,IAAId,sBAAsB;gBACxB,sEAAsE;gBACtE,OAAOgB,qBAAqBtB,YAAYoB;YAC1C,OAAO;gBACL,yJAAyJ;gBACzJ,OAAOG,gBAAgBH;YACzB;QACF;QACA,IAAIA,UAAUjB,IAAI,KAAK,KAAK;YAC1B,OAAOmB,qBAAqBtB,YAAYoB;QAC1C;QAEA,MAAMJ,YAAYhB,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAACE,UAAUjB,IAAI;QAE5F,IAAIa,WAAW;YACb,OAAOA,UAAUA,SAAS,CAAC;gBAAEQ,YAAYH;gBAAGrB;gBAAYO;gBAAgBa;YAAU;QACpF;QAEAK,QAAQC,IAAI,CAAC,wDAAwDN,UAAUjB,IAAI;QACnF,OAAOW,kBAAkBE,UAAU;YACjCQ,YAAYH;YACZrB;YACAO;YACAa;QACF;IACF,MAAM,EAAE;AAEZ;AAEA,OAAO,SAASE,qBACdtB,UAAgC,EAChC2B,IAAe;IAEf,OAAO;QACLxB,MAAM;QACNC,UAAUC,2BAA2B;YACnCC,sBAAsB;YACtBN;YACAO,gBAAgB;YAChBC,YAAYmB,KAAKvB,QAAQ,IAAI,EAAE;QACjC;QACAK,WAAW;QACXC,QAAQ;QACRC,QAAQ;QACRiB,YAAY;QACZC,WAAW;QACXjB,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAAe;IAC7C,OAAO;QACLxB,MAAM;QACN2B,QAAQ;QACRpB,QAAQqB,oBAAoBJ;QAC5BK,MAAM;QACNC,OAAO;QACPC,MAAMP,KAAKO,IAAI;QACftB,SAAS;IACX;AACF;AAEA,OAAO,SAASmB,oBAAoBJ,IAAe;IACjD,IAAIjB,SAAS;IACb,IAAIiB,KAAKQ,IAAI,EAAE;QACbzB,SAASA,SAASZ,WAAWsC,OAAO;IACtC;IACA,IAAIT,KAAKU,MAAM,EAAE;QACf3B,SAASA,SAASZ,WAAWwC,SAAS;IACxC;IACA,IAAIX,KAAKY,aAAa,EAAE;QACtB7B,SAASA,SAASZ,WAAW0C,gBAAgB;IAC/C;IACA,IAAIb,KAAKc,SAAS,EAAE;QAClB/B,SAASA,SAASZ,WAAW4C,YAAY;IAC3C;IACA,IAAIf,KAAKgB,SAAS,EAAE;QAClBjC,SAASA,SAASZ,WAAW8C,YAAY;IAC3C;IACA,IAAIjB,KAAKkB,WAAW,EAAE;QACpBnC,SAASA,SAASZ,WAAWgD,cAAc;IAC7C;IACA,IAAInB,KAAKoB,IAAI,EAAE;QACbrC,SAASA,SAASZ,WAAWkD,OAAO;IACtC;IACA,OAAOtC;AACT"}
+{"version":3,"file":"index.js","names":["NodeFormat","convertSlateToLexical","converters","slateData","root","type","children","convertSlateNodesToLexical","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","map","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","textFormat","textStyle","detail","convertNodeToFormat","mode","style","text","bold","IS_BOLD","italic","IS_ITALIC","strikethrough","IS_STRIKETHROUGH","underline","IS_UNDERLINE","subscript","IS_SUBSCRIPT","superscript","IS_SUPERSCRIPT","code","IS_CODE"],"sources":["../../../../../src/features/migrations/slateToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { SlateNode, SlateNodeConverter } from './types.js'\n\nimport { NodeFormat } from '../../../../lexical/utils/nodeFormat.js'\n\nexport function convertSlateToLexical({\n  converters,\n  slateData,\n}: {\n  converters: SlateNodeConverter[]\n  slateData: SlateNode[]\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: true,\n        converters,\n        parentNodeType: 'root',\n        slateNodes: slateData,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertSlateNodesToLexical({\n  canContainParagraphs,\n  converters,\n  parentNodeType,\n  slateNodes,\n}: {\n  canContainParagraphs: boolean\n  converters: SlateNodeConverter[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent slate type)\n   */\n  parentNodeType: string\n  slateNodes: SlateNode[]\n}): SerializedLexicalNode[] {\n  if (!converters?.length || !slateNodes?.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    slateNodes.map((slateNode, i) => {\n      if (!('type' in slateNode)) {\n        if (canContainParagraphs) {\n          // This is a paragraph node. They do not have a type property in Slate\n          return convertParagraphNode(converters, slateNode)\n        } else {\n          // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs\n          return convertTextNode(slateNode)\n        }\n      }\n      if (slateNode.type === 'p') {\n        return convertParagraphNode(converters, slateNode)\n      }\n\n      const converter = converters.find((converter) =>\n        converter.nodeTypes.includes(slateNode.type!),\n      )\n\n      if (converter) {\n        return converter.converter({ childIndex: i, converters, parentNodeType, slateNode })\n      }\n\n      console.warn('slateToLexical > No converter found for node type: ' + slateNode.type)\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        parentNodeType,\n        slateNode,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: SlateNodeConverter[],\n  node: SlateNode,\n): SerializedParagraphNode {\n  return {\n    type: 'paragraph',\n    children: convertSlateNodesToLexical({\n      canContainParagraphs: false,\n      converters,\n      parentNodeType: 'paragraph',\n      slateNodes: node.children || [],\n    }),\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    textStyle: '',\n    version: 1,\n  }\n}\nexport function convertTextNode(node: SlateNode): SerializedTextNode {\n  return {\n    type: 'text',\n    detail: 0,\n    format: convertNodeToFormat(node),\n    mode: 'normal',\n    style: '',\n    text: node.text,\n    version: 1,\n  }\n}\n\nexport function convertNodeToFormat(node: SlateNode): number {\n  let format = 0\n  if (node.bold) {\n    format = format | NodeFormat.IS_BOLD\n  }\n  if (node.italic) {\n    format = format | NodeFormat.IS_ITALIC\n  }\n  if (node.strikethrough) {\n    format = format | NodeFormat.IS_STRIKETHROUGH\n  }\n  if (node.underline) {\n    format = format | NodeFormat.IS_UNDERLINE\n  }\n  if (node.subscript) {\n    format = format | NodeFormat.IS_SUBSCRIPT\n  }\n  if (node.superscript) {\n    format = format | NodeFormat.IS_SUPERSCRIPT\n  }\n  if (node.code) {\n    format = format | NodeFormat.IS_CODE\n  }\n  return format\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -1,5 +1,4 @@
 import type { SerializedLexicalNode } from 'lexical';
-import type React from 'react';
 export type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
     converter: ({ childIndex, converters, parentNodeType, slateNode, }: {
         childIndex: number;
@@ -14,12 +13,4 @@ export type SlateNode = {
     children?: SlateNode[];
     type?: string;
 };
-export type SlateNodeConverterClientComponent = React.FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-export type SlateNodeConverterProvider = {
-    ClientConverter: SlateNodeConverterClientComponent;
-    converter: SlateNodeConverter;
-};
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACxF,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,SAAS,GACV,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,kBAAkB,EAAE,CAAA;QAChC,cAAc,EAAE,MAAM,CAAA;QACtB,SAAS,EAAE,SAAS,CAAA;KACrB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAA;IACtB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG,KAAK,CAAC,EAAE,CAAC;IACvD,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,eAAe,EAAE,iCAAiC,CAAA;IAClD,SAAS,EAAE,kBAAkB,CAAA;CAC9B,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACxF,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,SAAS,GACV,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,kBAAkB,EAAE,CAAA;QAChC,cAAc,EAAE,MAAM,CAAA;QACtB,SAAS,EAAE,SAAS,CAAA;KACrB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAA;IACtB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA"}

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

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

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type React from 'react'\n\nexport type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    parentNodeType,\n    slateNode,\n  }: {\n    childIndex: number\n    converters: SlateNodeConverter[]\n    parentNodeType: string\n    slateNode: SlateNode\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type SlateNode = {\n  [key: string]: any\n  children?: SlateNode[]\n  type?: string // doesn't always have type, e.g. for paragraphs\n}\n\nexport type SlateNodeConverterClientComponent = React.FC<{\n  componentKey: string\n  featureKey: string\n}>\n\nexport type SlateNodeConverterProvider = {\n  ClientConverter: SlateNodeConverterClientComponent\n  converter: SlateNodeConverter\n}\n"],"names":[],"mappings":"AA6BA,WAGC"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    parentNodeType,\n    slateNode,\n  }: {\n    childIndex: number\n    converters: SlateNodeConverter[]\n    parentNodeType: string\n    slateNode: SlateNode\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type SlateNode = {\n  [key: string]: any\n  children?: SlateNode[]\n  type?: string // doesn't always have type, e.g. for paragraphs\n}\n"],"mappings":"AAiBA","ignoreList":[]}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"names":[],"mappings":"AAQA,eAAO,MAAM,2BAA2B;;;EAwBtC,CAAA"}
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B,oFAItC,CAAA"}

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

@@ -1,27 +1,10 @@
 'use client';
+
 import { createClientFeature } from '../../../utilities/createClientFeature.js';
-import { convertSlateToLexical } from './converter/index.js';
 import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
-export const SlateToLexicalFeatureClient = createClientFeature(({ clientFunctions })=>{
-    const converters = Object.values(clientFunctions);
-    return {
-        hooks: {
-            load ({ incomingEditorState }) {
-                if (!incomingEditorState || !Array.isArray(incomingEditorState) || 'root' in incomingEditorState) {
-                    // incomingEditorState null or not from Slate
-                    return incomingEditorState;
-                }
-                // Slate => convert to lexical
-                return convertSlateToLexical({
-                    converters,
-                    slateData: incomingEditorState
-                });
-            }
-        },
-        nodes: [
-            UnknownConvertedNode
-        ]
-    };
+export const SlateToLexicalFeatureClient = createClientFeature(() => {
+  return {
+    nodes: [UnknownConvertedNode]
+  };
 });
-
 //# sourceMappingURL=feature.client.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { SlateNodeConverter } from './converter/types.js'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { convertSlateToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const SlateToLexicalFeatureClient = createClientFeature(({ clientFunctions }) => {\n  const converters: SlateNodeConverter[] = Object.values(clientFunctions)\n\n  return {\n    hooks: {\n      load({ incomingEditorState }) {\n        if (\n          !incomingEditorState ||\n          !Array.isArray(incomingEditorState) ||\n          'root' in incomingEditorState\n        ) {\n          // incomingEditorState null or not from Slate\n          return incomingEditorState\n        }\n        // Slate => convert to lexical\n\n        return convertSlateToLexical({\n          converters,\n          slateData: incomingEditorState,\n        })\n      },\n    },\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"names":["createClientFeature","convertSlateToLexical","UnknownConvertedNode","SlateToLexicalFeatureClient","clientFunctions","converters","Object","values","hooks","load","incomingEditorState","Array","isArray","slateData","nodes"],"mappings":"AAAA;AAIA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,qBAAqB,QAAQ,uBAAsB;AAC5D,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,OAAO,MAAMC,8BAA8BH,oBAAoB,CAAC,EAAEI,eAAe,EAAE;IACjF,MAAMC,aAAmCC,OAAOC,MAAM,CAACH;IAEvD,OAAO;QACLI,OAAO;YACLC,MAAK,EAAEC,mBAAmB,EAAE;gBAC1B,IACE,CAACA,uBACD,CAACC,MAAMC,OAAO,CAACF,wBACf,UAAUA,qBACV;oBACA,6CAA6C;oBAC7C,OAAOA;gBACT;gBACA,8BAA8B;gBAE9B,OAAOT,sBAAsB;oBAC3BI;oBACAQ,WAAWH;gBACb;YACF;QACF;QACAI,OAAO;YAACZ;SAAqB;IAC/B;AACF,GAAE"}
+{"version":3,"file":"feature.client.js","names":["createClientFeature","UnknownConvertedNode","SlateToLexicalFeatureClient","nodes"],"sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const SlateToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,2BAAA,GAA8BF,mBAAA,CAAoB;EAC7D,OAAO;IACLG,KAAA,EAAO,CAACF,oBAAA;EACV;AACF","ignoreList":[]}

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

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

package/dist/features/migrations/slateToLexical/feature.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAA;AAQtE,MAAM,MAAM,0BAA0B,GAAG;IACvC,UAAU,CAAC,EACP,CAAC,CAAC,EACA,iBAAiB,GAClB,EAAE;QACD,iBAAiB,EAAE,0BAA0B,EAAE,CAAA;KAChD,KAAK,0BAA0B,EAAE,CAAC,GACnC,0BAA0B,EAAE,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,qBAAqB;iBAGjB,0BAA0B,EAAE;aA8C3C,CAAA"}
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAO9D,MAAM,MAAM,0BAA0B,GAAG;IACvC,UAAU,CAAC,EACP,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE;QAAE,iBAAiB,EAAE,kBAAkB,EAAE,CAAA;KAAE,KAAK,kBAAkB,EAAE,CAAC,GAC9F,kBAAkB,EAAE,CAAA;IACxB,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,qBAAqB;iBAGjB,kBAAkB,EAAE;aAkDnC,CAAA"}

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

@@ -1,47 +1,50 @@
-// eslint-disable-next-line payload/no-imports-from-exports-dir
-import { SlateToLexicalFeatureClient } from '../../../exports/client/index.js';
 import { createServerFeature } from '../../../utilities/createServerFeature.js';
 import { defaultSlateConverters } from './converter/defaultConverters.js';
+import { convertSlateToLexical } from './converter/index.js';
 import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
 export const SlateToLexicalFeature = createServerFeature({
-    feature: ({ props })=>{
-        if (!props) {
-            props = {};
-        }
-        let converters = [];
-        if (props?.converters && typeof props?.converters === 'function') {
-            converters = props.converters({
-                defaultConverters: defaultSlateConverters
-            });
-        } else if (props.converters && typeof props?.converters !== 'function') {
-            converters = props.converters;
-        } else {
-            converters = defaultSlateConverters;
-        }
-        props.converters = converters;
-        return {
-            ClientFeature: SlateToLexicalFeatureClient,
-            generateComponentMap: ()=>{
-                const map = {};
-                for (const converter of converters){
-                    if (converter.ClientConverter) {
-                        const key = converter.converter.nodeTypes.join('-');
-                        map[key] = converter.ClientConverter;
-                    }
-                }
-                return map;
-            },
-            nodes: [
-                {
-                    node: UnknownConvertedNode
-                }
-            ],
-            sanitizedServerFeatureProps: {
-                converters
-            }
-        };
-    },
-    key: 'slateToLexical'
+  feature: ({
+    props
+  }) => {
+    if (!props) {
+      props = {};
+    }
+    let converters = [];
+    if (props?.converters && typeof props?.converters === 'function') {
+      converters = props.converters({
+        defaultConverters: defaultSlateConverters
+      });
+    } else if (props.converters && typeof props?.converters !== 'function') {
+      converters = props.converters;
+    } else {
+      converters = defaultSlateConverters;
+    }
+    props.converters = converters;
+    return {
+      ClientFeature: '@payloadcms/richtext-lexical/client#SlateToLexicalFeatureClient',
+      hooks: props.disableHooks ? undefined : {
+        afterRead: [({
+          value
+        }) => {
+          if (!value || !Array.isArray(value) || 'root' in value) {
+            // incomingEditorState null or not from Slate
+            return value;
+          }
+          // Slate => convert to lexical
+          return convertSlateToLexical({
+            converters: props.converters,
+            slateData: value
+          });
+        }]
+      },
+      nodes: [{
+        node: UnknownConvertedNode
+      }],
+      sanitizedServerFeatureProps: {
+        converters
+      }
+    };
+  },
+  key: 'slateToLexical'
 });
-
 //# sourceMappingURL=feature.server.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"sourcesContent":["import type React from 'react'\n\nimport type { SlateNodeConverterProvider } from './converter/types.js'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { SlateToLexicalFeatureClient } from '../../../exports/client/index.js'\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { defaultSlateConverters } from './converter/defaultConverters.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type SlateToLexicalFeatureProps = {\n  converters?:\n    | (({\n        defaultConverters,\n      }: {\n        defaultConverters: SlateNodeConverterProvider[]\n      }) => SlateNodeConverterProvider[])\n    | SlateNodeConverterProvider[]\n}\n\nexport const SlateToLexicalFeature = createServerFeature<\n  SlateToLexicalFeatureProps,\n  {\n    converters?: SlateNodeConverterProvider[]\n  }\n>({\n  feature: ({ props }) => {\n    if (!props) {\n      props = {}\n    }\n\n    let converters: SlateNodeConverterProvider[] = []\n    if (props?.converters && typeof props?.converters === 'function') {\n      converters = props.converters({ defaultConverters: defaultSlateConverters })\n    } else if (props.converters && typeof props?.converters !== 'function') {\n      converters = props.converters\n    } else {\n      converters = defaultSlateConverters\n    }\n\n    props.converters = converters\n\n    return {\n      ClientFeature: SlateToLexicalFeatureClient,\n      generateComponentMap: () => {\n        const map: {\n          [key: string]: React.FC\n        } = {}\n\n        for (const converter of converters) {\n          if (converter.ClientConverter) {\n            const key = converter.converter.nodeTypes.join('-')\n            map[key] = converter.ClientConverter\n          }\n        }\n\n        return map\n      },\n      nodes: [\n        {\n          node: UnknownConvertedNode,\n        },\n      ],\n      sanitizedServerFeatureProps: {\n        converters,\n      },\n    }\n  },\n  key: 'slateToLexical',\n})\n"],"names":["SlateToLexicalFeatureClient","createServerFeature","defaultSlateConverters","UnknownConvertedNode","SlateToLexicalFeature","feature","props","converters","defaultConverters","ClientFeature","generateComponentMap","map","converter","ClientConverter","key","nodeTypes","join","nodes","node","sanitizedServerFeatureProps"],"mappings":"AAIA,+DAA+D;AAC/D,SAASA,2BAA2B,QAAQ,mCAAkC;AAC9E,SAASC,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,sBAAsB,QAAQ,mCAAkC;AACzE,SAASC,oBAAoB,QAAQ,wCAAuC;AAY5E,OAAO,MAAMC,wBAAwBH,oBAKnC;IACAI,SAAS,CAAC,EAAEC,KAAK,EAAE;QACjB,IAAI,CAACA,OAAO;YACVA,QAAQ,CAAC;QACX;QAEA,IAAIC,aAA2C,EAAE;QACjD,IAAID,OAAOC,cAAc,OAAOD,OAAOC,eAAe,YAAY;YAChEA,aAAaD,MAAMC,UAAU,CAAC;gBAAEC,mBAAmBN;YAAuB;QAC5E,OAAO,IAAII,MAAMC,UAAU,IAAI,OAAOD,OAAOC,eAAe,YAAY;YACtEA,aAAaD,MAAMC,UAAU;QAC/B,OAAO;YACLA,aAAaL;QACf;QAEAI,MAAMC,UAAU,GAAGA;QAEnB,OAAO;YACLE,eAAeT;YACfU,sBAAsB;gBACpB,MAAMC,MAEF,CAAC;gBAEL,KAAK,MAAMC,aAAaL,WAAY;oBAClC,IAAIK,UAAUC,eAAe,EAAE;wBAC7B,MAAMC,MAAMF,UAAUA,SAAS,CAACG,SAAS,CAACC,IAAI,CAAC;wBAC/CL,GAAG,CAACG,IAAI,GAAGF,UAAUC,eAAe;oBACtC;gBACF;gBAEA,OAAOF;YACT;YACAM,OAAO;gBACL;oBACEC,MAAMf;gBACR;aACD;YACDgB,6BAA6B;gBAC3BZ;YACF;QACF;IACF;IACAO,KAAK;AACP,GAAE"}
+{"version":3,"file":"feature.server.js","names":["createServerFeature","defaultSlateConverters","convertSlateToLexical","UnknownConvertedNode","SlateToLexicalFeature","feature","props","converters","defaultConverters","ClientFeature","hooks","disableHooks","undefined","afterRead","value","Array","isArray","slateData","nodes","node","sanitizedServerFeatureProps","key"],"sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"sourcesContent":["import type { SlateNodeConverter } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { defaultSlateConverters } from './converter/defaultConverters.js'\nimport { convertSlateToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type SlateToLexicalFeatureProps = {\n  converters?:\n    | (({ defaultConverters }: { defaultConverters: SlateNodeConverter[] }) => SlateNodeConverter[])\n    | SlateNodeConverter[]\n  disableHooks?: boolean\n}\n\nexport const SlateToLexicalFeature = createServerFeature<\n  SlateToLexicalFeatureProps,\n  {\n    converters?: SlateNodeConverter[]\n  }\n>({\n  feature: ({ props }) => {\n    if (!props) {\n      props = {}\n    }\n\n    let converters: SlateNodeConverter[] = []\n    if (props?.converters && typeof props?.converters === 'function') {\n      converters = props.converters({ defaultConverters: defaultSlateConverters })\n    } else if (props.converters && typeof props?.converters !== 'function') {\n      converters = props.converters\n    } else {\n      converters = defaultSlateConverters\n    }\n\n    props.converters = converters\n\n    return {\n      ClientFeature: '@payloadcms/richtext-lexical/client#SlateToLexicalFeatureClient',\n      hooks: props.disableHooks\n        ? undefined\n        : {\n            afterRead: [\n              ({ value }) => {\n                if (!value || !Array.isArray(value) || 'root' in value) {\n                  // incomingEditorState null or not from Slate\n                  return value\n                }\n\n                // Slate => convert to lexical\n                return convertSlateToLexical({\n                  converters: props.converters as SlateNodeConverter[],\n                  slateData: value,\n                })\n              },\n            ],\n          },\n      nodes: [\n        {\n          node: UnknownConvertedNode,\n        },\n      ],\n      sanitizedServerFeatureProps: {\n        converters,\n      },\n    }\n  },\n  key: 'slateToLexical',\n})\n"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,oBAAoB,QAAQ;AASrC,OAAO,MAAMC,qBAAA,GAAwBJ,mBAAA,CAKnC;EACAK,OAAA,EAASA,CAAC;IAAEC;EAAK,CAAE;IACjB,IAAI,CAACA,KAAA,EAAO;MACVA,KAAA,GAAQ,CAAC;IACX;IAEA,IAAIC,UAAA,GAAmC,EAAE;IACzC,IAAID,KAAA,EAAOC,UAAA,IAAc,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MAChEA,UAAA,GAAaD,KAAA,CAAMC,UAAU,CAAC;QAAEC,iBAAA,EAAmBP;MAAuB;IAC5E,OAAO,IAAIK,KAAA,CAAMC,UAAU,IAAI,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MACtEA,UAAA,GAAaD,KAAA,CAAMC,UAAU;IAC/B,OAAO;MACLA,UAAA,GAAaN,sBAAA;IACf;IAEAK,KAAA,CAAMC,UAAU,GAAGA,UAAA;IAEnB,OAAO;MACLE,aAAA,EAAe;MACfC,KAAA,EAAOJ,KAAA,CAAMK,YAAY,GACrBC,SAAA,GACA;QACEC,SAAA,EAAW,CACT,CAAC;UAAEC;QAAK,CAAE;UACR,IAAI,CAACA,KAAA,IAAS,CAACC,KAAA,CAAMC,OAAO,CAACF,KAAA,KAAU,UAAUA,KAAA,EAAO;YACtD;YACA,OAAOA,KAAA;UACT;UAEA;UACA,OAAOZ,qBAAA,CAAsB;YAC3BK,UAAA,EAAYD,KAAA,CAAMC,UAAU;YAC5BU,SAAA,EAAWH;UACb;QACF;MAEJ;MACJI,KAAA,EAAO,CACL;QACEC,IAAA,EAAMhB;MACR,EACD;MACDiB,2BAAA,EAA6B;QAC3Bb;MACF;IACF;EACF;EACAc,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Component.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE1D,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,wBAAwB,CAAA;CAC/B,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAQzD,CAAA"}
+{"version":3,"file":"Component.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE1D,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,wBAAwB,CAAA;CAC/B,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAQzD,CAAA"}

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

@@ -1,15 +1,15 @@
+'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 Slate node: ",
-            /*#__PURE__*/ _jsx("strong", {
-                children: data?.nodeType
-            })
-        ]
-    });
+export const UnknownConvertedNodeComponent = props => {
+  const {
+    data
+  } = props;
+  return /*#__PURE__*/_jsxs("div", {
+    children: ["Unknown converted Slate node: ", /*#__PURE__*/_jsx("strong", {
+      children: data?.nodeType
+    })]
+  });
 };
-
 //# sourceMappingURL=Component.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["import 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 Slate node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"names":["React","UnknownConvertedNodeComponent","props","data","div","strong","nodeType"],"mappings":";AAAA,OAAOA,WAAW,QAAO;AAUzB,OAAO,MAAMC,gCAAiD,CAACC;IAC7D,MAAM,EAAEC,IAAI,EAAE,GAAGD;IAEjB,qBACE,MAACE;;YAAI;0BAC2B,KAACC;0BAAQF,MAAMG;;;;AAGnD,EAAC"}
+{"version":3,"file":"Component.js","names":["React","UnknownConvertedNodeComponent","props","data","_jsxs","_jsx","nodeType"],"sources":["../../../../../../src/features/migrations/slateToLexical/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 Slate 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,kC,aAC2BC,IAAA,CAAC;gBAAQF,IAAA,EAAMG;;;AAGnD","ignoreList":[]}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.d.ts

@@ -21,7 +21,7 @@ export declare class UnknownConvertedNode extends DecoratorNode<JSX.Element> {
     canInsertTextAfter(): true;
     canInsertTextBefore(): true;
     createDOM(config: EditorConfig): HTMLElement;
-    decorate(): JSX.Element | null;
+    decorate(): JSX.Element;
     exportJSON(): SerializedUnknownConvertedNode;
     isInline(): boolean;
     updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean;

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvC,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG,MAAM,CACjD;IACE,IAAI,EAAE,wBAAwB,CAAA;CAC/B,EACD,qBAAqB,CACtB,CAAA;AAQD,oBAAoB;AACpB,qBAAa,oBAAqB,SAAQ,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC;IAClE,MAAM,EAAE,wBAAwB,CAAA;gBAEpB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAAE,IAAI,EAAE,wBAAwB,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;IAK5E,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,oBAAoB,GAAG,oBAAoB;IAO9D,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,8BAA8B,GAAG,oBAAoB;IAKvF,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,IAAI;IAI3B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,QAAQ,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI;IAI9B,UAAU,IAAI,8BAA8B;IAU5C,QAAQ,IAAI,OAAO;IAInB,SAAS,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;CAGrE;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GAAG,oBAAoB,CAIvB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,oBAAoB,CAE9B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvC,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG,MAAM,CACjD;IACE,IAAI,EAAE,wBAAwB,CAAA;CAC/B,EACD,qBAAqB,CACtB,CAAA;AAQD,oBAAoB;AACpB,qBAAa,oBAAqB,SAAQ,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC;IAClE,MAAM,EAAE,wBAAwB,CAAA;gBAEpB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAAE,IAAI,EAAE,wBAAwB,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;IAK5E,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,oBAAoB,GAAG,oBAAoB;IAO9D,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,8BAA8B,GAAG,oBAAoB;IAKvF,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,IAAI;IAI3B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,QAAQ,IAAI,GAAG,CAAC,OAAO;IAIvB,UAAU,IAAI,8BAA8B;IAU5C,QAAQ,IAAI,OAAO;IAInB,SAAS,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;CAGrE;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GAAG,oBAAoB,CAIvB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,oBAAoB,CAE9B"}