@payloadcms/richtext-lexical 3.0.0-canary.95fcd13 → 3.0.0-canary.9beaa28

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    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","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;QACZhB,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAAe;IAC7C,OAAO;QACLxB,MAAM;QACN0B,QAAQ;QACRnB,QAAQoB,oBAAoBH;QAC5BI,MAAM;QACNC,OAAO;QACPC,MAAMN,KAAKM,IAAI;QACfrB,SAAS;IACX;AACF;AAEA,OAAO,SAASkB,oBAAoBH,IAAe;IACjD,IAAIjB,SAAS;IACb,IAAIiB,KAAKO,IAAI,EAAE;QACbxB,SAASA,SAASZ,WAAWqC,OAAO;IACtC;IACA,IAAIR,KAAKS,MAAM,EAAE;QACf1B,SAASA,SAASZ,WAAWuC,SAAS;IACxC;IACA,IAAIV,KAAKW,aAAa,EAAE;QACtB5B,SAASA,SAASZ,WAAWyC,gBAAgB;IAC/C;IACA,IAAIZ,KAAKa,SAAS,EAAE;QAClB9B,SAASA,SAASZ,WAAW2C,YAAY;IAC3C;IACA,IAAId,KAAKe,SAAS,EAAE;QAClBhC,SAASA,SAASZ,WAAW6C,YAAY;IAC3C;IACA,IAAIhB,KAAKiB,WAAW,EAAE;QACpBlC,SAASA,SAASZ,WAAW+C,cAAc;IAC7C;IACA,IAAIlB,KAAKmB,IAAI,EAAE;QACbpC,SAASA,SAASZ,WAAWiD,OAAO;IACtC;IACA,OAAOrC;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  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"],"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.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;;;EAItC,CAAA"}

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

@@ -1,27 +1,12 @@
 '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(({
+  clientFunctions
+}) => {
+  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","clientFunctions","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(({ clientFunctions }) => {\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,CAAC;EAAEG;AAAe,CAAE;EACjF,OAAO;IACLC,KAAA,EAAO,CAACH,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.js

@@ -2,68 +2,73 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { addClassNamesToElement } from '@lexical/utils';
 import { DecoratorNode } from 'lexical';
 import * as React from 'react';
-const Component = /*#__PURE__*/ React.lazy(()=>import('./Component.js').then((module)=>({
-            default: module.UnknownConvertedNodeComponent
-        })));
-/** @noInheritDoc */ export class UnknownConvertedNode extends DecoratorNode {
-    __data;
-    constructor({ data, key }){
-        super(key);
-        this.__data = data;
-    }
-    static clone(node) {
-        return new UnknownConvertedNode({
-            data: node.__data,
-            key: node.__key
-        });
-    }
-    static getType() {
-        return 'unknownConverted';
-    }
-    static importJSON(serializedNode) {
-        const node = $createUnknownConvertedNode({
-            data: serializedNode.data
-        });
-        return node;
-    }
-    canInsertTextAfter() {
-        return true;
-    }
-    canInsertTextBefore() {
-        return true;
-    }
-    createDOM(config) {
-        const element = document.createElement('span');
-        addClassNamesToElement(element, 'unknownConverted');
-        return element;
-    }
-    decorate() {
-        return /*#__PURE__*/ _jsx(Component, {
-            data: this.__data
-        });
-    }
-    exportJSON() {
-        return {
-            type: this.getType(),
-            data: this.__data,
-            version: 1
-        };
-    }
-    // Mutation
-    isInline() {
-        return true;
-    }
-    updateDOM(prevNode, dom) {
-        return false;
-    }
-}
-export function $createUnknownConvertedNode({ data }) {
+const Component = /*#__PURE__*/React.lazy(() => import('./Component.js').then(module => ({
+  default: module.UnknownConvertedNodeComponent
+})));
+/** @noInheritDoc */
+export class UnknownConvertedNode extends DecoratorNode {
+  __data;
+  constructor({
+    data,
+    key
+  }) {
+    super(key);
+    this.__data = data;
+  }
+  static clone(node) {
     return new UnknownConvertedNode({
-        data
+      data: node.__data,
+      key: node.__key
+    });
+  }
+  static getType() {
+    return 'unknownConverted';
+  }
+  static importJSON(serializedNode) {
+    const node = $createUnknownConvertedNode({
+      data: serializedNode.data
     });
+    return node;
+  }
+  canInsertTextAfter() {
+    return true;
+  }
+  canInsertTextBefore() {
+    return true;
+  }
+  createDOM(config) {
+    const element = document.createElement('span');
+    addClassNamesToElement(element, 'unknownConverted');
+    return element;
+  }
+  decorate() {
+    return /*#__PURE__*/_jsx(Component, {
+      data: this.__data
+    });
+  }
+  exportJSON() {
+    return {
+      type: this.getType(),
+      data: this.__data,
+      version: 1
+    };
+  }
+  // Mutation
+  isInline() {
+    return true;
+  }
+  updateDOM(prevNode, dom) {
+    return false;
+  }
+}
+export function $createUnknownConvertedNode({
+  data
+}) {
+  return new UnknownConvertedNode({
+    data
+  });
 }
 export function $isUnknownConvertedNode(node) {
-    return node instanceof UnknownConvertedNode;
+  return node instanceof UnknownConvertedNode;
 }
-
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { DecoratorNode } from 'lexical'\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n  nodeData: unknown\n  nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n  {\n    data: UnknownConvertedNodeData\n  },\n  SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n  import('./Component.js').then((module) => ({\n    default: module.UnknownConvertedNodeComponent,\n  })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n  __data: UnknownConvertedNodeData\n\n  constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n    super(key)\n    this.__data = data\n  }\n\n  static clone(node: UnknownConvertedNode): UnknownConvertedNode {\n    return new UnknownConvertedNode({\n      data: node.__data,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'unknownConverted'\n  }\n\n  static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode {\n    const node = $createUnknownConvertedNode({ data: serializedNode.data })\n    return node\n  }\n\n  canInsertTextAfter(): true {\n    return true\n  }\n\n  canInsertTextBefore(): true {\n    return true\n  }\n\n  createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('span')\n    addClassNamesToElement(element, 'unknownConverted')\n    return element\n  }\n\n  decorate(): JSX.Element | null {\n    return <Component data={this.__data} />\n  }\n\n  exportJSON(): SerializedUnknownConvertedNode {\n    return {\n      type: this.getType(),\n      data: this.__data,\n      version: 1,\n    }\n  }\n\n  // Mutation\n\n  isInline(): boolean {\n    return true\n  }\n\n  updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean {\n    return false\n  }\n}\n\nexport function $createUnknownConvertedNode({\n  data,\n}: {\n  data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n  return new UnknownConvertedNode({\n    data,\n  })\n}\n\nexport function $isUnknownConvertedNode(\n  node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n  return node instanceof UnknownConvertedNode\n}\n"],"names":["addClassNamesToElement","DecoratorNode","React","Component","lazy","then","module","default","UnknownConvertedNodeComponent","UnknownConvertedNode","__data","constructor","data","key","clone","node","__key","getType","importJSON","serializedNode","$createUnknownConvertedNode","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","decorate","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"mappings":";AAGA,SAASA,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,aAAa,QAAQ,UAAS;AACvC,YAAYC,WAAW,QAAO;AAc9B,MAAMC,0BAAYD,MAAME,IAAI,CAAC,IAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAC,CAACC,SAAY,CAAA;YACzCC,SAASD,OAAOE,6BAA6B;QAC/C,CAAA;AAGF,kBAAkB,GAClB,OAAO,MAAMC,6BAA6BR;IACxCS,OAAgC;IAEhCC,YAAY,EAAEC,IAAI,EAAEC,GAAG,EAAqD,CAAE;QAC5E,KAAK,CAACA;QACN,IAAI,CAACH,MAAM,GAAGE;IAChB;IAEA,OAAOE,MAAMC,IAA0B,EAAwB;QAC7D,OAAO,IAAIN,qBAAqB;YAC9BG,MAAMG,KAAKL,MAAM;YACjBG,KAAKE,KAAKC,KAAK;QACjB;IACF;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA,OAAOC,WAAWC,cAA8C,EAAwB;QACtF,MAAMJ,OAAOK,4BAA4B;YAAER,MAAMO,eAAeP,IAAI;QAAC;QACrE,OAAOG;IACT;IAEAM,qBAA2B;QACzB,OAAO;IACT;IAEAC,sBAA4B;QAC1B,OAAO;IACT;IAEAC,UAAUC,MAAoB,EAAe;QAC3C,MAAMC,UAAUC,SAASC,aAAa,CAAC;QACvC3B,uBAAuByB,SAAS;QAChC,OAAOA;IACT;IAEAG,WAA+B;QAC7B,qBAAO,KAACzB;YAAUS,MAAM,IAAI,CAACF,MAAM;;IACrC;IAEAmB,aAA6C;QAC3C,OAAO;YACLC,MAAM,IAAI,CAACb,OAAO;YAClBL,MAAM,IAAI,CAACF,MAAM;YACjBqB,SAAS;QACX;IACF;IAEA,WAAW;IAEXC,WAAoB;QAClB,OAAO;IACT;IAEAC,UAAUC,QAA8B,EAAEC,GAAgB,EAAW;QACnE,OAAO;IACT;AACF;AAEA,OAAO,SAASf,4BAA4B,EAC1CR,IAAI,EAGL;IACC,OAAO,IAAIH,qBAAqB;QAC9BG;IACF;AACF;AAEA,OAAO,SAASwB,wBACdrB,IAAoC;IAEpC,OAAOA,gBAAgBN;AACzB"}
+{"version":3,"file":"index.js","names":["addClassNamesToElement","DecoratorNode","React","Component","lazy","then","module","default","UnknownConvertedNodeComponent","UnknownConvertedNode","__data","constructor","data","key","clone","node","__key","getType","importJSON","serializedNode","$createUnknownConvertedNode","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","decorate","_jsx","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { DecoratorNode } from 'lexical'\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n  nodeData: unknown\n  nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n  {\n    data: UnknownConvertedNodeData\n  },\n  SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n  import('./Component.js').then((module) => ({\n    default: module.UnknownConvertedNodeComponent,\n  })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n  __data: UnknownConvertedNodeData\n\n  constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n    super(key)\n    this.__data = data\n  }\n\n  static clone(node: UnknownConvertedNode): UnknownConvertedNode {\n    return new UnknownConvertedNode({\n      data: node.__data,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'unknownConverted'\n  }\n\n  static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode {\n    const node = $createUnknownConvertedNode({ data: serializedNode.data })\n    return node\n  }\n\n  canInsertTextAfter(): true {\n    return true\n  }\n\n  canInsertTextBefore(): true {\n    return true\n  }\n\n  createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('span')\n    addClassNamesToElement(element, 'unknownConverted')\n    return element\n  }\n\n  decorate(): JSX.Element | null {\n    return <Component data={this.__data} />\n  }\n\n  exportJSON(): SerializedUnknownConvertedNode {\n    return {\n      type: this.getType(),\n      data: this.__data,\n      version: 1,\n    }\n  }\n\n  // Mutation\n\n  isInline(): boolean {\n    return true\n  }\n\n  updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean {\n    return false\n  }\n}\n\nexport function $createUnknownConvertedNode({\n  data,\n}: {\n  data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n  return new UnknownConvertedNode({\n    data,\n  })\n}\n\nexport function $isUnknownConvertedNode(\n  node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n  return node instanceof UnknownConvertedNode\n}\n"],"mappings":";AAGA,SAASA,sBAAsB,QAAQ;AACvC,SAASC,aAAa,QAAQ;AAC9B,YAAYC,KAAA,MAAW;AAcvB,MAAMC,SAAA,gBAAYD,KAAA,CAAME,IAAI,CAAC,MAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAEC,MAAA,KAAY;EACzCC,OAAA,EAASD,MAAA,CAAOE;AAClB;AAGF;AACA,OAAO,MAAMC,oBAAA,SAA6BR,aAAA;EACxCS,MAAA;EAEAC,YAAY;IAAEC,IAAI;IAAEC;EAAG,CAAqD,EAAE;IAC5E,KAAK,CAACA,GAAA;IACN,IAAI,CAACH,MAAM,GAAGE,IAAA;EAChB;EAEA,OAAOE,MAAMC,IAA0B,EAAwB;IAC7D,OAAO,IAAIN,oBAAA,CAAqB;MAC9BG,IAAA,EAAMG,IAAA,CAAKL,MAAM;MACjBG,GAAA,EAAKE,IAAA,CAAKC;IACZ;EACF;EAEA,OAAOC,QAAA,EAAkB;IACvB,OAAO;EACT;EAEA,OAAOC,WAAWC,cAA8C,EAAwB;IACtF,MAAMJ,IAAA,GAAOK,2BAAA,CAA4B;MAAER,IAAA,EAAMO,cAAA,CAAeP;IAAK;IACrE,OAAOG,IAAA;EACT;EAEAM,mBAAA,EAA2B;IACzB,OAAO;EACT;EAEAC,oBAAA,EAA4B;IAC1B,OAAO;EACT;EAEAC,UAAUC,MAAoB,EAAe;IAC3C,MAAMC,OAAA,GAAUC,QAAA,CAASC,aAAa,CAAC;IACvC3B,sBAAA,CAAuByB,OAAA,EAAS;IAChC,OAAOA,OAAA;EACT;EAEAG,SAAA,EAA+B;IAC7B,oBAAOC,IAAA,CAAC1B,SAAA;MAAUS,IAAA,EAAM,IAAI,CAACF;;EAC/B;EAEAoB,WAAA,EAA6C;IAC3C,OAAO;MACLC,IAAA,EAAM,IAAI,CAACd,OAAO;MAClBL,IAAA,EAAM,IAAI,CAACF,MAAM;MACjBsB,OAAA,EAAS;IACX;EACF;EAEA;EAEAC,SAAA,EAAoB;IAClB,OAAO;EACT;EAEAC,UAAUC,QAA8B,EAAEC,GAAgB,EAAW;IACnE,OAAO;EACT;AACF;AAEA,OAAO,SAAShB,4BAA4B;EAC1CR;AAAI,CAGL;EACC,OAAO,IAAIH,oBAAA,CAAqB;IAC9BG;EACF;AACF;AAEA,OAAO,SAASyB,wBACdtB,IAAoC;EAEpC,OAAOA,IAAA,YAAgBN,oBAAA;AACzB","ignoreList":[]}

package/dist/features/paragraph/client/index.d.ts

@@ -0,0 +1,5 @@
+export declare const ParagraphFeatureClient: import("react").FC<{
+    featureKey: string;
+    order: number;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/paragraph/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/paragraph/client/index.tsx"],"names":[],"mappings":"AA0CA,eAAO,MAAM,sBAAsB;;;EA2BjC,CAAA"}

package/dist/features/paragraph/client/index.js

@@ -0,0 +1,68 @@
+'use client';
+
+import { $setBlocksType } from '@lexical/selection';
+import { $createParagraphNode, $getSelection, $isParagraphNode, $isRangeSelection } from 'lexical';
+import { TextIcon } from '../../../lexical/ui/icons/Text/index.js';
+import { createClientFeature } from '../../../utilities/createClientFeature.js';
+import { slashMenuBasicGroupWithItems } from '../../shared/slashMenu/basicGroup.js';
+import { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js';
+const toolbarGroups = [toolbarTextDropdownGroupWithItems([{
+  ChildComponent: TextIcon,
+  isActive: ({
+    selection
+  }) => {
+    if (!$isRangeSelection(selection)) {
+      return false;
+    }
+    for (const node of selection.getNodes()) {
+      if (!$isParagraphNode(node) && !$isParagraphNode(node.getParent())) {
+        return false;
+      }
+    }
+    return true;
+  },
+  key: 'paragraph',
+  label: ({
+    i18n
+  }) => {
+    return i18n.t('lexical:paragraph:label2');
+  },
+  onSelect: ({
+    editor
+  }) => {
+    editor.update(() => {
+      const selection = $getSelection();
+      $setBlocksType(selection, () => $createParagraphNode());
+    });
+  },
+  order: 1
+}])];
+export const ParagraphFeatureClient = createClientFeature({
+  slashMenu: {
+    groups: [slashMenuBasicGroupWithItems([{
+      Icon: TextIcon,
+      key: 'paragraph',
+      keywords: ['normal', 'paragraph', 'p', 'text'],
+      label: ({
+        i18n
+      }) => {
+        return i18n.t('lexical:paragraph:label');
+      },
+      onSelect: ({
+        editor
+      }) => {
+        editor.update(() => {
+          const selection = $getSelection();
+          $setBlocksType(selection, () => $createParagraphNode());
+        });
+      }
+    }])]
+  },
+  toolbarFixed: {
+    groups: toolbarGroups
+  },
+  toolbarInline: {
+    groups: toolbarGroups
+  }
+});
+//# sourceMappingURL=index.js.map

package/dist/features/paragraph/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["$setBlocksType","$createParagraphNode","$getSelection","$isParagraphNode","$isRangeSelection","TextIcon","createClientFeature","slashMenuBasicGroupWithItems","toolbarTextDropdownGroupWithItems","toolbarGroups","ChildComponent","isActive","selection","node","getNodes","getParent","key","label","i18n","t","onSelect","editor","update","order","ParagraphFeatureClient","slashMenu","groups","Icon","keywords","toolbarFixed","toolbarInline"],"sources":["../../../../src/features/paragraph/client/index.tsx"],"sourcesContent":["'use client'\n\nimport { $setBlocksType } from '@lexical/selection'\nimport { $createParagraphNode, $getSelection, $isParagraphNode, $isRangeSelection } from 'lexical'\n\nimport type { ToolbarGroup } from '../../toolbars/types.js'\n\nimport { TextIcon } from '../../../lexical/ui/icons/Text/index.js'\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { slashMenuBasicGroupWithItems } from '../../shared/slashMenu/basicGroup.js'\nimport { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js'\n\nconst toolbarGroups: ToolbarGroup[] = [\n  toolbarTextDropdownGroupWithItems([\n    {\n      ChildComponent: TextIcon,\n      isActive: ({ selection }) => {\n        if (!$isRangeSelection(selection)) {\n          return false\n        }\n        for (const node of selection.getNodes()) {\n          if (!$isParagraphNode(node) && !$isParagraphNode(node.getParent())) {\n            return false\n          }\n        }\n        return true\n      },\n      key: 'paragraph',\n      label: ({ i18n }) => {\n        return i18n.t('lexical:paragraph:label2')\n      },\n      onSelect: ({ editor }) => {\n        editor.update(() => {\n          const selection = $getSelection()\n          $setBlocksType(selection, () => $createParagraphNode())\n        })\n      },\n      order: 1,\n    },\n  ]),\n]\n\nexport const ParagraphFeatureClient = createClientFeature({\n  slashMenu: {\n    groups: [\n      slashMenuBasicGroupWithItems([\n        {\n          Icon: TextIcon,\n          key: 'paragraph',\n          keywords: ['normal', 'paragraph', 'p', 'text'],\n          label: ({ i18n }) => {\n            return i18n.t('lexical:paragraph:label')\n          },\n          onSelect: ({ editor }) => {\n            editor.update(() => {\n              const selection = $getSelection()\n              $setBlocksType(selection, () => $createParagraphNode())\n            })\n          },\n        },\n      ]),\n    ],\n  },\n  toolbarFixed: {\n    groups: toolbarGroups,\n  },\n  toolbarInline: {\n    groups: toolbarGroups,\n  },\n})\n"],"mappings":"AAAA;;AAEA,SAASA,cAAc,QAAQ;AAC/B,SAASC,oBAAoB,EAAEC,aAAa,EAAEC,gBAAgB,EAAEC,iBAAiB,QAAQ;AAIzF,SAASC,QAAQ,QAAQ;AACzB,SAASC,mBAAmB,QAAQ;AACpC,SAASC,4BAA4B,QAAQ;AAC7C,SAASC,iCAAiC,QAAQ;AAElD,MAAMC,aAAA,GAAgC,CACpCD,iCAAA,CAAkC,CAChC;EACEE,cAAA,EAAgBL,QAAA;EAChBM,QAAA,EAAUA,CAAC;IAAEC;EAAS,CAAE;IACtB,IAAI,CAACR,iBAAA,CAAkBQ,SAAA,GAAY;MACjC,OAAO;IACT;IACA,KAAK,MAAMC,IAAA,IAAQD,SAAA,CAAUE,QAAQ,IAAI;MACvC,IAAI,CAACX,gBAAA,CAAiBU,IAAA,KAAS,CAACV,gBAAA,CAAiBU,IAAA,CAAKE,SAAS,KAAK;QAClE,OAAO;MACT;IACF;IACA,OAAO;EACT;EACAC,GAAA,EAAK;EACLC,KAAA,EAAOA,CAAC;IAAEC;EAAI,CAAE;IACd,OAAOA,IAAA,CAAKC,CAAC,CAAC;EAChB;EACAC,QAAA,EAAUA,CAAC;IAAEC;EAAM,CAAE;IACnBA,MAAA,CAAOC,MAAM,CAAC;MACZ,MAAMV,SAAA,GAAYV,aAAA;MAClBF,cAAA,CAAeY,SAAA,EAAW,MAAMX,oBAAA;IAClC;EACF;EACAsB,KAAA,EAAO;AACT,EACD,EACF;AAED,OAAO,MAAMC,sBAAA,GAAyBlB,mBAAA,CAAoB;EACxDmB,SAAA,EAAW;IACTC,MAAA,EAAQ,CACNnB,4BAAA,CAA6B,CAC3B;MACEoB,IAAA,EAAMtB,QAAA;MACNW,GAAA,EAAK;MACLY,QAAA,EAAU,CAAC,UAAU,aAAa,KAAK,OAAO;MAC9CX,KAAA,EAAOA,CAAC;QAAEC;MAAI,CAAE;QACd,OAAOA,IAAA,CAAKC,CAAC,CAAC;MAChB;MACAC,QAAA,EAAUA,CAAC;QAAEC;MAAM,CAAE;QACnBA,MAAA,CAAOC,MAAM,CAAC;UACZ,MAAMV,SAAA,GAAYV,aAAA;UAClBF,cAAA,CAAeY,SAAA,EAAW,MAAMX,oBAAA;QAClC;MACF;IACF,EACD;EAEL;EACA4B,YAAA,EAAc;IACZH,MAAA,EAAQjB;EACV;EACAqB,aAAA,EAAe;IACbJ,MAAA,EAAQjB;EACV;AACF","ignoreList":[]}

package/dist/features/paragraph/server/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../../../src/features/paragraph/server/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE,eAAO,MAAM,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAiI1C,CAAA"}