@payloadcms/richtext-lexical 3.84.1 → 4.0.0-internal.d28e9fb

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

@@ -1,12 +0,0 @@
-import { SlateBlockquoteConverter } from './converters/blockquote/converter.js';
-import { SlateHeadingConverter } from './converters/heading/converter.js';
-import { SlateIndentConverter } from './converters/indent/converter.js';
-import { SlateLinkConverter } from './converters/link/converter.js';
-import { SlateListItemConverter } from './converters/listItem/converter.js';
-import { SlateOrderedListConverter } from './converters/orderedList/converter.js';
-import { SlateRelationshipConverter } from './converters/relationship/converter.js';
-import { SlateUnknownConverter } from './converters/unknown/converter.js';
-import { SlateUnorderedListConverter } from './converters/unorderedList/converter.js';
-import { SlateUploadConverter } from './converters/upload/converter.js';
-export const defaultSlateConverters = [SlateBlockquoteConverter, SlateHeadingConverter, SlateIndentConverter, SlateLinkConverter, SlateListItemConverter, SlateOrderedListConverter, SlateRelationshipConverter, SlateUnorderedListConverter, SlateUploadConverter, SlateUnknownConverter];
-//# sourceMappingURL=defaultConverters.js.map

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

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

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

@@ -1,19 +0,0 @@
-import type { SerializedEditorState, SerializedLexicalNode, SerializedParagraphNode, SerializedTextNode } from 'lexical';
-import type { SlateNode, SlateNodeConverter } from './types.js';
-export declare function convertSlateToLexical({ converters, slateData, }: {
-    converters: SlateNodeConverter[];
-    slateData: SlateNode[];
-}): SerializedEditorState;
-export declare function convertSlateNodesToLexical({ canContainParagraphs, converters, parentNodeType, slateNodes, }: {
-    canContainParagraphs: boolean;
-    converters: SlateNodeConverter[] | undefined;
-    /**
-     * Type of the parent lexical node (not the type of the original, parent slate type)
-     */
-    parentNodeType: string;
-    slateNodes: SlateNode[];
-}): SerializedLexicalNode[];
-export declare function convertParagraphNode(converters: SlateNodeConverter[], node: SlateNode): SerializedParagraphNode;
-export declare function convertTextNode(node: SlateNode): SerializedTextNode;
-export declare function convertNodeToFormat(node: SlateNode): number;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/slateToLexical/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAI/D,wBAAgB,qBAAqB,CAAC,EACpC,UAAU,EACV,SAAS,GACV,EAAE;IACD,UAAU,EAAE,kBAAkB,EAAE,CAAA;IAChC,SAAS,EAAE,SAAS,EAAE,CAAA;CACvB,GAAG,qBAAqB,CAgBxB;AAED,wBAAgB,0BAA0B,CAAC,EACzC,oBAAoB,EACpB,UAAU,EACV,cAAc,EACd,UAAU,GACX,EAAE;IACD,oBAAoB,EAAE,OAAO,CAAA;IAC7B,UAAU,EAAE,kBAAkB,EAAE,GAAG,SAAS,CAAA;IAC5C;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,SAAS,EAAE,CAAA;CACxB,GAAG,qBAAqB,EAAE,CAiD1B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,kBAAkB,EAAE,EAChC,IAAI,EAAE,SAAS,GACd,uBAAuB,CAgBzB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,kBAAkB,CAUnE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAwB3D"}

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

@@ -1,130 +0,0 @@
-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 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 (
-    // Flatten in case we unwrap an array of child nodes
-    slateNodes.flatMap((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 {
-          // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text
-          // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children
-          if (slateNode.children) {
-            return convertSlateNodesToLexical({
-              canContainParagraphs,
-              converters,
-              parentNodeType,
-              slateNodes: slateNode.children || []
-            });
-          }
-          // 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
-      });
-    }) || []
-  );
-}
-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
-  };
-}
-export function convertTextNode(node) {
-  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;
-}
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"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","flatMap","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    // Flatten in case we unwrap an array of child nodes\n    slateNodes.flatMap((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          // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text\n          // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children\n          if (slateNode.children) {\n            return convertSlateNodesToLexical({\n              canContainParagraphs,\n              converters,\n              parentNodeType,\n              slateNodes: slateNode.children || [],\n            })\n          }\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":"AASA,SAASA,UAAU,QAAQ;AAE3B,OAAO,SAASC,sBAAsB;EACpCC,UAAU;EACVC;AAAS,CAIV;EACC,OAAO;IACLC,IAAA,EAAM;MACJC,IAAA,EAAM;MACNC,QAAA,EAAUC,0BAAA,CAA2B;QACnCC,oBAAA,EAAsB;QACtBN,UAAA;QACAO,cAAA,EAAgB;QAChBC,UAAA,EAAYP;MACd;MACAQ,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;AACF;AAEA,OAAO,SAASP,2BAA2B;EACzCC,oBAAoB;EACpBN,UAAU;EACVO,cAAc;EACdC;AAAU,CASX;EACC,IAAI,CAACR,UAAA,EAAYa,MAAA,IAAU,CAACL,UAAA,EAAYK,MAAA,EAAQ;IAC9C,OAAO,EAAE;EACX;EACA,MAAMC,gBAAA,GAAmBd,UAAA,CAAWe,IAAI,CAAEC,SAAA,IAAcA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAAC;EACrF;EACA;IACE;IACAV,UAAA,CAAWW,OAAO,CAAC,CAACC,SAAA,EAAWC,CAAA;MAC7B,IAAI,EAAE,UAAUD,SAAQ,GAAI;QAC1B,IAAId,oBAAA,EAAsB;UACxB;UACA,OAAOgB,oBAAA,CAAqBtB,UAAA,EAAYoB,SAAA;QAC1C,OAAO;UACL;UACA;UACA,IAAIA,SAAA,CAAUhB,QAAQ,EAAE;YACtB,OAAOC,0BAAA,CAA2B;cAChCC,oBAAA;cACAN,UAAA;cACAO,cAAA;cACAC,UAAA,EAAYY,SAAA,CAAUhB,QAAQ,IAAI;YACpC;UACF;UACA;UACA,OAAOmB,eAAA,CAAgBH,SAAA;QACzB;MACF;MACA,IAAIA,SAAA,CAAUjB,IAAI,KAAK,KAAK;QAC1B,OAAOmB,oBAAA,CAAqBtB,UAAA,EAAYoB,SAAA;MAC1C;MAEA,MAAMJ,SAAA,GAAYhB,UAAA,CAAWe,IAAI,CAAEC,SAAA,IACjCA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAACE,SAAA,CAAUjB,IAAI;MAG7C,IAAIa,SAAA,EAAW;QACb,OAAOA,SAAA,CAAUA,SAAS,CAAC;UAAEQ,UAAA,EAAYH,CAAA;UAAGrB,UAAA;UAAYO,cAAA;UAAgBa;QAAU;MACpF;MAEAK,OAAA,CAAQC,IAAI,CAAC,wDAAwDN,SAAA,CAAUjB,IAAI;MACnF,OAAOW,gBAAA,EAAkBE,SAAA,CAAU;QACjCQ,UAAA,EAAYH,CAAA;QACZrB,UAAA;QACAO,cAAA;QACAa;MACF;IACF,MAAM;EAAE;AAEZ;AAEA,OAAO,SAASE,qBACdtB,UAAgC,EAChC2B,IAAe;EAEf,OAAO;IACLxB,IAAA,EAAM;IACNC,QAAA,EAAUC,0BAAA,CAA2B;MACnCC,oBAAA,EAAsB;MACtBN,UAAA;MACAO,cAAA,EAAgB;MAChBC,UAAA,EAAYmB,IAAA,CAAKvB,QAAQ,IAAI;IAC/B;IACAK,SAAA,EAAW;IACXC,MAAA,EAAQ;IACRC,MAAA,EAAQ;IACRiB,UAAA,EAAY;IACZC,SAAA,EAAW;IACXjB,OAAA,EAAS;EACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAAe;EAC7C,OAAO;IACLxB,IAAA,EAAM;IACN2B,MAAA,EAAQ;IACRpB,MAAA,EAAQqB,mBAAA,CAAoBJ,IAAA;IAC5BK,IAAA,EAAM;IACNC,KAAA,EAAO;IACPC,IAAA,EAAMP,IAAA,CAAKO,IAAI,IAAI;IACnBtB,OAAA,EAAS;EACX;AACF;AAEA,OAAO,SAASmB,oBAAoBJ,IAAe;EACjD,IAAIjB,MAAA,GAAS;EACb,IAAIiB,IAAA,CAAKQ,IAAI,EAAE;IACbzB,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAWsC,OAAO;EACtC;EACA,IAAIT,IAAA,CAAKU,MAAM,EAAE;IACf3B,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAWwC,SAAS;EACxC;EACA,IAAIX,IAAA,CAAKY,aAAa,EAAE;IACtB7B,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAW0C,gBAAgB;EAC/C;EACA,IAAIb,IAAA,CAAKc,SAAS,EAAE;IAClB/B,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAW4C,YAAY;EAC3C;EACA,IAAIf,IAAA,CAAKgB,SAAS,EAAE;IAClBjC,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAW8C,YAAY;EAC3C;EACA,IAAIjB,IAAA,CAAKkB,WAAW,EAAE;IACpBnC,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAWgD,cAAc;EAC7C;EACA,IAAInB,IAAA,CAAKoB,IAAI,EAAE;IACbrC,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAWkD,OAAO;EACtC;EACA,OAAOtC,MAAA;AACT","ignoreList":[]}

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

@@ -1,16 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-export type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
-    converter: ({ childIndex, converters, parentNodeType, slateNode, }: {
-        childIndex: number;
-        converters: SlateNodeConverter[];
-        parentNodeType: string;
-        slateNode: SlateNode;
-    }) => T;
-    nodeTypes: string[];
-};
-export type SlateNode = {
-    [key: string]: any;
-    children?: SlateNode[];
-    type?: string;
-};
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"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,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

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

@@ -1 +0,0 @@
-{"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,2 +0,0 @@
-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 +0,0 @@
-{"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,10 +0,0 @@
-'use client';
-
-import { createClientFeature } from '../../../utilities/createClientFeature.js';
-import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
-export const SlateToLexicalFeatureClient = createClientFeature(() => {
-  return {
-    nodes: [UnknownConvertedNode]
-  };
-});
-//# sourceMappingURL=feature.client.js.map

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

@@ -1 +0,0 @@
-{"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,40 +0,0 @@
-import type { SlateNodeConverter } from './converter/types.js';
-export type SlateToLexicalFeatureProps = {
-    /**
-     * Custom converters to transform Slate nodes to Lexical nodes.
-     * Can be an array of converters or a function that receives default converters and returns an array.
-     * @default defaultSlateConverters
-     */
-    converters?: (({ defaultConverters }: {
-        defaultConverters: SlateNodeConverter[];
-    }) => SlateNodeConverter[]) | SlateNodeConverter[];
-    /**
-     * When true, disables the afterRead hook that converts Slate data on-the-fly.
-     * Set this to true when running the migration script. That way, this feature is only used
-     * to "pass through" the converters to the migration script.
-     * @default false
-     */
-    disableHooks?: boolean;
-};
-/**
- * Enables on-the-fly conversion of Slate data to Lexical format through an afterRead hook.
- * Used for testing migrations before running the permanent migration script.
- * Only converts data that is in Slate format (arrays); Lexical data passes through unchanged.
- *
- * @example
- * ```ts
- * lexicalEditor({
- *   features: ({ defaultFeatures }) => [
- *     ...defaultFeatures,
- *     SlateToLexicalFeature({
- *       converters: [...defaultSlateConverters, MyCustomConverter],
- *       disableHooks: false, // Set to true during migration script
- *     }),
- *   ],
- * })
- * ```
- */
-export declare const SlateToLexicalFeature: import("../../typesServer.js").FeatureProviderProviderServer<SlateToLexicalFeatureProps, {
-    converters?: SlateNodeConverter[];
-}, undefined>;
-//# sourceMappingURL=feature.server.d.ts.map

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

@@ -1 +0,0 @@
-{"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;;;;OAIG;IACH,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;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB;iBAGjB,kBAAkB,EAAE;aAkDnC,CAAA"}

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

@@ -1,68 +0,0 @@
-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';
-/**
- * Enables on-the-fly conversion of Slate data to Lexical format through an afterRead hook.
- * Used for testing migrations before running the permanent migration script.
- * Only converts data that is in Slate format (arrays); Lexical data passes through unchanged.
- *
- * @example
- * ```ts
- * lexicalEditor({
- *   features: ({ defaultFeatures }) => [
- *     ...defaultFeatures,
- *     SlateToLexicalFeature({
- *       converters: [...defaultSlateConverters, MyCustomConverter],
- *       disableHooks: false, // Set to true during migration script
- *     }),
- *   ],
- * })
- * ```
- */
-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: '@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 +0,0 @@
-{"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  /**\n   * Custom converters to transform Slate nodes to Lexical nodes.\n   * Can be an array of converters or a function that receives default converters and returns an array.\n   * @default defaultSlateConverters\n   */\n  converters?:\n    | (({ defaultConverters }: { defaultConverters: SlateNodeConverter[] }) => SlateNodeConverter[])\n    | SlateNodeConverter[]\n  /**\n   * When true, disables the afterRead hook that converts Slate data on-the-fly.\n   * Set this to true when running the migration script. That way, this feature is only used\n   * to \"pass through\" the converters to the migration script.\n   * @default false\n   */\n  disableHooks?: boolean\n}\n\n/**\n * Enables on-the-fly conversion of Slate data to Lexical format through an afterRead hook.\n * Used for testing migrations before running the permanent migration script.\n * Only converts data that is in Slate format (arrays); Lexical data passes through unchanged.\n *\n * @example\n * ```ts\n * lexicalEditor({\n *   features: ({ defaultFeatures }) => [\n *     ...defaultFeatures,\n *     SlateToLexicalFeature({\n *       converters: [...defaultSlateConverters, MyCustomConverter],\n *       disableHooks: false, // Set to true during migration script\n *     }),\n *   ],\n * })\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;AAoBrC;;;;;;;;;;;;;;;;;;AAkBA,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

@@ -1,9 +0,0 @@
-import React from 'react';
-import type { UnknownConvertedNodeData } from './index.js';
-import './index.scss';
-type Props = {
-    data: UnknownConvertedNodeData;
-};
-export declare const UnknownConvertedNodeComponent: React.FC<Props>;
-export {};
-//# sourceMappingURL=Component.d.ts.map

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

@@ -1 +0,0 @@
-{"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 +0,0 @@
-'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
-    })]
-  });
-};
-//# sourceMappingURL=Component.js.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,33 +0,0 @@
-import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
-import type { JSX } from 'react';
-import { DecoratorNode } from 'lexical';
-export type UnknownConvertedNodeData = {
-    nodeData: unknown;
-    nodeType: string;
-};
-export type SerializedUnknownConvertedNode = Spread<{
-    data: UnknownConvertedNodeData;
-}, SerializedLexicalNode>;
-/** @noInheritDoc */
-export declare class UnknownConvertedNode extends DecoratorNode<JSX.Element> {
-    __data: UnknownConvertedNodeData;
-    constructor({ data, key }: {
-        data: UnknownConvertedNodeData;
-        key?: NodeKey;
-    });
-    static clone(node: UnknownConvertedNode): UnknownConvertedNode;
-    static getType(): string;
-    static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode;
-    canInsertTextAfter(): true;
-    canInsertTextBefore(): true;
-    createDOM(config: EditorConfig): HTMLElement;
-    decorate(): JSX.Element;
-    exportJSON(): SerializedUnknownConvertedNode;
-    isInline(): boolean;
-    updateDOM(prevNode: this, dom: HTMLElement): boolean;
-}
-export declare function $createUnknownConvertedNode({ data, }: {
-    data: UnknownConvertedNodeData;
-}): UnknownConvertedNode;
-export declare function $isUnknownConvertedNode(node: LexicalNode | null | undefined): node is UnknownConvertedNode;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"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,EAAyB,aAAa,EAAE,MAAM,SAAS,CAAA;AAG9D,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;WAK5D,KAAK,CAAC,IAAI,EAAE,oBAAoB,GAAG,oBAAoB;WAOvD,OAAO,IAAI,MAAM;WAIjB,UAAU,CAAC,cAAc,EAAE,8BAA8B,GAAG,oBAAoB;IAKhG,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,IAAI;IAIlB,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,IAAI,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;CAG9D;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GAAG,oBAAoB,CAMvB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,oBAAoB,CAE9B"}

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

@@ -1,74 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { addClassNamesToElement } from '@lexical/utils';
-import { $applyNodeReplacement, 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 this({
-      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 $applyNodeReplacement(new UnknownConvertedNode({
-    data
-  }));
-}
-export function $isUnknownConvertedNode(node) {
-  return node instanceof UnknownConvertedNode;
-}
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["addClassNamesToElement","$applyNodeReplacement","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 { $applyNodeReplacement, 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 override clone(node: UnknownConvertedNode): UnknownConvertedNode {\n    return new this({\n      data: node.__data,\n      key: node.__key,\n    })\n  }\n\n  static override getType(): string {\n    return 'unknownConverted'\n  }\n\n  static override 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  override createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('span')\n    addClassNamesToElement(element, 'unknownConverted')\n    return element\n  }\n\n  override decorate(): JSX.Element {\n    return <Component data={this.__data} />\n  }\n\n  override exportJSON(): SerializedUnknownConvertedNode {\n    return {\n      type: this.getType(),\n      data: this.__data,\n      version: 1,\n    }\n  }\n\n  // Mutation\n\n  override isInline(): boolean {\n    return true\n  }\n\n  override updateDOM(prevNode: this, dom: HTMLElement): boolean {\n    return false\n  }\n}\n\nexport function $createUnknownConvertedNode({\n  data,\n}: {\n  data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n  return $applyNodeReplacement(\n    new UnknownConvertedNode({\n      data,\n    }),\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,qBAAqB,EAAEC,aAAa,QAAQ;AACrD,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,OAAgBE,MAAMC,IAA0B,EAAwB;IACtE,OAAO,IAAI,IAAI,CAAC;MACdH,IAAA,EAAMG,IAAA,CAAKL,MAAM;MACjBG,GAAA,EAAKE,IAAA,CAAKC;IACZ;EACF;EAEA,OAAgBC,QAAA,EAAkB;IAChC,OAAO;EACT;EAEA,OAAgBC,WAAWC,cAA8C,EAAwB;IAC/F,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;EAESC,UAAUC,MAAoB,EAAe;IACpD,MAAMC,OAAA,GAAUC,QAAA,CAASC,aAAa,CAAC;IACvC5B,sBAAA,CAAuB0B,OAAA,EAAS;IAChC,OAAOA,OAAA;EACT;EAESG,SAAA,EAAwB;IAC/B,oBAAOC,IAAA,CAAC1B,SAAA;MAAUS,IAAA,EAAM,IAAI,CAACF;;EAC/B;EAESoB,WAAA,EAA6C;IACpD,OAAO;MACLC,IAAA,EAAM,IAAI,CAACd,OAAO;MAClBL,IAAA,EAAM,IAAI,CAACF,MAAM;MACjBsB,OAAA,EAAS;IACX;EACF;EAEA;EAESC,SAAA,EAAoB;IAC3B,OAAO;EACT;EAESC,UAAUC,QAAc,EAAEC,GAAgB,EAAW;IAC5D,OAAO;EACT;AACF;AAEA,OAAO,SAAShB,4BAA4B;EAC1CR;AAAI,CAGL;EACC,OAAOZ,qBAAA,CACL,IAAIS,oBAAA,CAAqB;IACvBG;EACF;AAEJ;AAEA,OAAO,SAASyB,wBACdtB,IAAoC;EAEpC,OAAOA,IAAA,YAAgBN,oBAAA;AACzB","ignoreList":[]}

package/dist/lexical/ui/icons/AI/index.d.ts

@@ -1,3 +0,0 @@
-import React from 'react';
-export declare const AIIcon: React.FC;
-//# sourceMappingURL=index.d.ts.map

package/dist/lexical/ui/icons/AI/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lexical/ui/icons/AI/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,EAyB1B,CAAA"}

package/dist/lexical/ui/icons/AI/index.js

@@ -1,34 +0,0 @@
-'use client';
-
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from 'react';
-export const AIIcon = () => /*#__PURE__*/_jsxs("svg", {
-  "aria-hidden": "true",
-  className: "icon",
-  fill: "none",
-  focusable: "false",
-  height: "20",
-  viewBox: "0 0 20 20",
-  width: "20",
-  xmlns: "http://www.w3.org/2000/svg",
-  children: [/*#__PURE__*/_jsx("g", {
-    clipPath: "url(#clip0_4393_10389)",
-    children: /*#__PURE__*/_jsx("path", {
-      d: "M6.25 4.75V7M5.125 5.875L7.375 5.875M6.25 13V14.125M6.25 14.125V15.25M6.25 14.125H5.125M6.25 14.125H7.375M10.75 5.5L11.2171 6.66785C11.7399 7.97466 12.7753 9.01014 14.0822 9.53286L15.25 10L13.686 10.782C12.6191 11.3154 11.7708 12.2032 11.2864 13.2932L10.75 14.5L10.2136 13.2932C9.72919 12.2032 8.8809 11.3154 7.814 10.782L6.25 10L7.41785 9.53286C8.72466 9.01014 9.76014 7.97466 10.2829 6.66785L10.75 5.5Z",
-      stroke: "currentColor",
-      strokeLinecap: "round",
-      strokeLinejoin: "round"
-    })
-  }), /*#__PURE__*/_jsx("defs", {
-    children: /*#__PURE__*/_jsx("clipPath", {
-      id: "clip0_4393_10389",
-      children: /*#__PURE__*/_jsx("rect", {
-        fill: "white",
-        height: "12",
-        transform: "translate(4 4)",
-        width: "12"
-      })
-    })
-  })]
-});
-//# sourceMappingURL=index.js.map

package/dist/lexical/ui/icons/AI/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["React","AIIcon","_jsxs","className","fill","focusable","height","viewBox","width","xmlns","_jsx","clipPath","d","stroke","strokeLinecap","strokeLinejoin","id","transform"],"sources":["../../../../../src/lexical/ui/icons/AI/index.tsx"],"sourcesContent":["'use client'\nimport React from 'react'\n\nexport const AIIcon: React.FC = () => (\n  <svg\n    aria-hidden=\"true\"\n    className=\"icon\"\n    fill=\"none\"\n    focusable=\"false\"\n    height=\"20\"\n    viewBox=\"0 0 20 20\"\n    width=\"20\"\n    xmlns=\"http://www.w3.org/2000/svg\"\n  >\n    <g clipPath=\"url(#clip0_4393_10389)\">\n      <path\n        d=\"M6.25 4.75V7M5.125 5.875L7.375 5.875M6.25 13V14.125M6.25 14.125V15.25M6.25 14.125H5.125M6.25 14.125H7.375M10.75 5.5L11.2171 6.66785C11.7399 7.97466 12.7753 9.01014 14.0822 9.53286L15.25 10L13.686 10.782C12.6191 11.3154 11.7708 12.2032 11.2864 13.2932L10.75 14.5L10.2136 13.2932C9.72919 12.2032 8.8809 11.3154 7.814 10.782L6.25 10L7.41785 9.53286C8.72466 9.01014 9.76014 7.97466 10.2829 6.66785L10.75 5.5Z\"\n        stroke=\"currentColor\"\n        strokeLinecap=\"round\"\n        strokeLinejoin=\"round\"\n      />\n    </g>\n    <defs>\n      <clipPath id=\"clip0_4393_10389\">\n        <rect fill=\"white\" height=\"12\" transform=\"translate(4 4)\" width=\"12\" />\n      </clipPath>\n    </defs>\n  </svg>\n)\n"],"mappings":"AAAA;;;AACA,OAAOA,KAAA,MAAW;AAElB,OAAO,MAAMC,MAAA,GAAmBA,CAAA,kBAC9BC,KAAA,CAAC;EACC,eAAY;EACZC,SAAA,EAAU;EACVC,IAAA,EAAK;EACLC,SAAA,EAAU;EACVC,MAAA,EAAO;EACPC,OAAA,EAAQ;EACRC,KAAA,EAAM;EACNC,KAAA,EAAM;0BAENC,IAAA,CAAC;IAAEC,QAAA,EAAS;cACV,aAAAD,IAAA,CAAC;MACCE,CAAA,EAAE;MACFC,MAAA,EAAO;MACPC,aAAA,EAAc;MACdC,cAAA,EAAe;;mBAGnBL,IAAA,CAAC;cACC,aAAAA,IAAA,CAAC;MAASM,EAAA,EAAG;gBACX,aAAAN,IAAA,CAAC;QAAKN,IAAA,EAAK;QAAQE,MAAA,EAAO;QAAKW,SAAA,EAAU;QAAiBT,KAAA,EAAM","ignoreList":[]}

package/dist/lexical/ui/icons/Caret/index.svg

@@ -1,3 +0,0 @@
-<svg width="7" height="4" viewBox="0 0 7 4" fill="none" xmlns="http://www.w3.org/2000/svg">
-    <path d="M1.25 3.5L3.75 1L6.25 3.5" />
-</svg>

package/dist/lexical/ui/icons/Edit/index.svg

@@ -1,10 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-    <path
-        d="M14.2293 14.6187H5.55926V5.96867H9.84926V4.38867H3.98926V16.1887H15.8093V10.2887H14.2293V14.6187Z"
-        fill="currentColor" />
-    <path
-        d="M13.6188 5.08887L14.7288 6.19887L9.96885 10.9589L8.81885 10.9989L8.85885 9.84887L13.6188 5.08887Z"
-        fill="currentColor" />
-    <path d="M16.0108 4.92778L14.8936 3.81055L14.0804 4.62372L15.1976 5.74095L16.0108 4.92778Z"
-        fill="currentColor" />
-</svg>

package/dist/lexical/ui/icons/Remove/index.svg

@@ -1,4 +0,0 @@
-<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
-    <path d="M15 5L5.00021 15" stroke="currentColor" stroke-width="1.5" />
-    <path d="M5.00049 5L15.0003 15" stroke="currentColor" stroke-width="1.5" />
-</svg>

package/dist/utilities/migrateSlateToLexical/index.d.ts

@@ -1,15 +0,0 @@
-import type { Payload } from 'payload';
-/**
- * This goes through every single collection and field in the payload config, and migrates its data from Slate to Lexical. This does not support sub-fields within slate.
- *
- * It will only translate fields fulfilling all these requirements:
- * - field schema uses lexical editor
- * - lexical editor has SlateToLexicalFeature added
- * - saved field data is in Slate format
- *
- * @param payload
- */
-export declare function migrateSlateToLexical({ payload }: {
-    payload: Payload;
-}): Promise<void>;
-//# sourceMappingURL=index.d.ts.map