@payloadcms/richtext-lexical 3.71.0-internal-debug.e053082 → 3.71.0-internal.49c4f67

package/dist/features/converters/lexicalToPlaintext/sync/index.js

@@ -1,89 +1,88 @@
-/* eslint-disable no-console */ import { hasText } from '../../../../validate/hasText.js';
+/* eslint-disable no-console */import { hasText } from '../../../../validate/hasText.js';
 import { findConverterForNode } from '../shared/findConverterForNode.js';
-/**
-   * A map of node types to their corresponding plaintext converter functions.
-   * This is optional - if not provided, the following heuristic will be used:
-   *
-   * - If the node has a `text` property, it will be used as the plaintext.
-   * - If the node has a `children` property, the children will be recursively converted to plaintext.
-   * - If the node has neither, it will be ignored.
-   **/ export function convertLexicalToPlaintext({ converters, data }) {
-    if (hasText(data)) {
-        const plaintext = convertLexicalNodesToPlaintext({
-            converters: converters ?? {},
-            nodes: data?.root?.children,
-            parent: data?.root
-        }).join('');
-        return plaintext;
-    }
-    return '';
+export function convertLexicalToPlaintext({
+  converters,
+  data
+}) {
+  if (hasText(data)) {
+    const plaintext = convertLexicalNodesToPlaintext({
+      converters: converters ?? {},
+      nodes: data?.root?.children,
+      parent: data?.root
+    }).join('');
+    return plaintext;
+  }
+  return '';
 }
-export function convertLexicalNodesToPlaintext({ converters, nodes, parent }) {
-    const plainTextArray = [];
-    let i = -1;
-    for (const node of nodes){
-        i++;
-        const converter = findConverterForNode({
-            converters,
-            node
-        });
-        if (converter) {
-            try {
-                const converted = typeof converter === 'function' ? converter({
-                    childIndex: i,
-                    converters,
-                    node,
-                    nodesToPlaintext: (args)=>{
-                        return convertLexicalNodesToPlaintext({
-                            converters: args.converters ?? converters,
-                            nodes: args.nodes,
-                            parent: args.parent ?? {
-                                ...node,
-                                parent
-                            }
-                        });
-                    },
-                    parent
-                }) : converter;
-                if (converted && typeof converted === 'string') {
-                    plainTextArray.push(converted);
-                }
-            } catch (error) {
-                console.error('Error converting lexical node to plaintext:', error, 'node:', node);
-            }
-        } else {
-            // Default plaintext converter heuristic
-            if (node.type === 'paragraph' || node.type === 'heading' || node.type === 'list' || node.type === 'table') {
-                if (plainTextArray?.length) {
-                    // Only add a new line if there is already text in the array
-                    plainTextArray.push('\n\n');
-                }
-            } else if (node.type === 'listitem' || node.type === 'tablerow') {
-                if (plainTextArray?.length) {
-                    // Only add a new line if there is already text in the array
-                    plainTextArray.push('\n');
-                }
-            } else if (node.type === 'tablecell') {
-                if (plainTextArray?.length) {
-                    plainTextArray.push(' | ');
-                }
-            } else if (node.type === 'linebreak') {
-                plainTextArray.push('\n');
-            } else if (node.type === 'tab') {
-                plainTextArray.push('\t');
-            } else if ('text' in node && node.text) {
-                plainTextArray.push(node.text);
-            }
-            if ('children' in node && node.children) {
-                plainTextArray.push(...convertLexicalNodesToPlaintext({
-                    converters,
-                    nodes: node.children,
-                    parent: node
-                }));
-            }
+export function convertLexicalNodesToPlaintext({
+  converters,
+  nodes,
+  parent
+}) {
+  const plainTextArray = [];
+  let i = -1;
+  for (const node of nodes) {
+    i++;
+    const converter = findConverterForNode({
+      converters,
+      node
+    });
+    if (converter) {
+      try {
+        const converted = typeof converter === 'function' ? converter({
+          childIndex: i,
+          converters,
+          node,
+          nodesToPlaintext: args => {
+            return convertLexicalNodesToPlaintext({
+              converters: args.converters ?? converters,
+              nodes: args.nodes,
+              parent: args.parent ?? {
+                ...node,
+                parent
+              }
+            });
+          },
+          parent
+        }) : converter;
+        if (converted && typeof converted === 'string') {
+          plainTextArray.push(converted);
+        }
+      } catch (error) {
+        console.error('Error converting lexical node to plaintext:', error, 'node:', node);
+      }
+    } else {
+      // Default plaintext converter heuristic
+      if (node.type === 'paragraph' || node.type === 'heading' || node.type === 'list' || node.type === 'table') {
+        if (plainTextArray?.length) {
+          // Only add a new line if there is already text in the array
+          plainTextArray.push('\n\n');
+        }
+      } else if (node.type === 'listitem' || node.type === 'tablerow') {
+        if (plainTextArray?.length) {
+          // Only add a new line if there is already text in the array
+          plainTextArray.push('\n');
+        }
+      } else if (node.type === 'tablecell') {
+        if (plainTextArray?.length) {
+          plainTextArray.push(' | ');
         }
+      } else if (node.type === 'linebreak') {
+        plainTextArray.push('\n');
+      } else if (node.type === 'tab') {
+        plainTextArray.push('\t');
+      } else if ('text' in node && node.text) {
+        plainTextArray.push(node.text);
+      }
+      if ('children' in node && node.children) {
+        plainTextArray.push(...convertLexicalNodesToPlaintext({
+          converters,
+          nodes: node.children,
+          parent: node
+        }));
+      }
     }
-    return plainTextArray.filter(Boolean);
+  }
+  return plainTextArray.filter(Boolean);
 }
-
 //# sourceMappingURL=index.js.map

package/dist/features/converters/lexicalToPlaintext/sync/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/index.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nimport type { PlaintextConverters } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\n\nexport type ConvertLexicalToPlaintextArgs = {\n  /**\n   * A map of node types to their corresponding plaintext converter functions.\n   * This is optional - if not provided, the following heuristic will be used:\n   *\n   * - If the node has a `text` property, it will be used as the plaintext.\n   * - If the node has a `children` property, the children will be recursively converted to plaintext.\n   * - If the node has neither, it will be ignored.\n   **/\n  converters?: PlaintextConverters\n  data: SerializedEditorState\n}\n\nexport function convertLexicalToPlaintext({\n  converters,\n  data,\n}: ConvertLexicalToPlaintextArgs): string {\n  if (hasText(data)) {\n    const plaintext = convertLexicalNodesToPlaintext({\n      converters: converters ?? {},\n      nodes: data?.root?.children,\n      parent: data?.root,\n    }).join('')\n\n    return plaintext\n  }\n  return ''\n}\n\nexport function convertLexicalNodesToPlaintext({\n  converters,\n  nodes,\n  parent,\n}: {\n  converters: PlaintextConverters\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): string[] {\n  const plainTextArray: string[] = []\n\n  let i = -1\n  for (const node of nodes) {\n    i++\n\n    const converter = findConverterForNode({\n      converters,\n      node,\n    })\n\n    if (converter) {\n      try {\n        const converted =\n          typeof converter === 'function'\n            ? converter({\n                childIndex: i,\n                converters,\n                node,\n                nodesToPlaintext: (args) => {\n                  return convertLexicalNodesToPlaintext({\n                    converters: args.converters ?? converters,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                  })\n                },\n                parent,\n              })\n            : converter\n\n        if (converted && typeof converted === 'string') {\n          plainTextArray.push(converted)\n        }\n      } catch (error) {\n        console.error('Error converting lexical node to plaintext:', error, 'node:', node)\n      }\n    } else {\n      // Default plaintext converter heuristic\n      if (\n        node.type === 'paragraph' ||\n        node.type === 'heading' ||\n        node.type === 'list' ||\n        node.type === 'table'\n      ) {\n        if (plainTextArray?.length) {\n          // Only add a new line if there is already text in the array\n          plainTextArray.push('\\n\\n')\n        }\n      } else if (node.type === 'listitem' || node.type === 'tablerow') {\n        if (plainTextArray?.length) {\n          // Only add a new line if there is already text in the array\n          plainTextArray.push('\\n')\n        }\n      } else if (node.type === 'tablecell') {\n        if (plainTextArray?.length) {\n          plainTextArray.push(' | ')\n        }\n      } else if (node.type === 'linebreak') {\n        plainTextArray.push('\\n')\n      } else if (node.type === 'tab') {\n        plainTextArray.push('\\t')\n      } else if ('text' in node && node.text) {\n        plainTextArray.push(node.text as string)\n      }\n\n      if ('children' in node && node.children) {\n        plainTextArray.push(\n          ...convertLexicalNodesToPlaintext({\n            converters,\n            nodes: node.children as SerializedLexicalNode[],\n            parent: node,\n          }),\n        )\n      }\n    }\n  }\n\n  return plainTextArray.filter(Boolean)\n}\n"],"names":["hasText","findConverterForNode","convertLexicalToPlaintext","converters","data","plaintext","convertLexicalNodesToPlaintext","nodes","root","children","parent","join","plainTextArray","i","node","converter","converted","childIndex","nodesToPlaintext","args","push","error","console","type","length","text","filter","Boolean"],"mappings":"AAAA,6BAA6B,GAM7B,SAASA,OAAO,QAAQ,kCAAiC;AACzD,SAASC,oBAAoB,QAAQ,oCAAmC;AAGtE;;;;;;;IAOE,GAKJ,OAAO,SAASC,0BAA0B,EACxCC,UAAU,EACVC,IAAI,EAC0B;IAC9B,IAAIJ,QAAQI,OAAO;QACjB,MAAMC,YAAYC,+BAA+B;YAC/CH,YAAYA,cAAc,CAAC;YAC3BI,OAAOH,MAAMI,MAAMC;YACnBC,QAAQN,MAAMI;QAChB,GAAGG,IAAI,CAAC;QAER,OAAON;IACT;IACA,OAAO;AACT;AAEA,OAAO,SAASC,+BAA+B,EAC7CH,UAAU,EACVI,KAAK,EACLG,MAAM,EAKP;IACC,MAAME,iBAA2B,EAAE;IAEnC,IAAIC,IAAI,CAAC;IACT,KAAK,MAAMC,QAAQP,MAAO;QACxBM;QAEA,MAAME,YAAYd,qBAAqB;YACrCE;YACAW;QACF;QAEA,IAAIC,WAAW;YACb,IAAI;gBACF,MAAMC,YACJ,OAAOD,cAAc,aACjBA,UAAU;oBACRE,YAAYJ;oBACZV;oBACAW;oBACAI,kBAAkB,CAACC;wBACjB,OAAOb,+BAA+B;4BACpCH,YAAYgB,KAAKhB,UAAU,IAAIA;4BAC/BI,OAAOY,KAAKZ,KAAK;4BACjBG,QAAQS,KAAKT,MAAM,IAAI;gCACrB,GAAGI,IAAI;gCACPJ;4BACF;wBACF;oBACF;oBACAA;gBACF,KACAK;gBAEN,IAAIC,aAAa,OAAOA,cAAc,UAAU;oBAC9CJ,eAAeQ,IAAI,CAACJ;gBACtB;YACF,EAAE,OAAOK,OAAO;gBACdC,QAAQD,KAAK,CAAC,+CAA+CA,OAAO,SAASP;YAC/E;QACF,OAAO;YACL,wCAAwC;YACxC,IACEA,KAAKS,IAAI,KAAK,eACdT,KAAKS,IAAI,KAAK,aACdT,KAAKS,IAAI,KAAK,UACdT,KAAKS,IAAI,KAAK,SACd;gBACA,IAAIX,gBAAgBY,QAAQ;oBAC1B,4DAA4D;oBAC5DZ,eAAeQ,IAAI,CAAC;gBACtB;YACF,OAAO,IAAIN,KAAKS,IAAI,KAAK,cAAcT,KAAKS,IAAI,KAAK,YAAY;gBAC/D,IAAIX,gBAAgBY,QAAQ;oBAC1B,4DAA4D;oBAC5DZ,eAAeQ,IAAI,CAAC;gBACtB;YACF,OAAO,IAAIN,KAAKS,IAAI,KAAK,aAAa;gBACpC,IAAIX,gBAAgBY,QAAQ;oBAC1BZ,eAAeQ,IAAI,CAAC;gBACtB;YACF,OAAO,IAAIN,KAAKS,IAAI,KAAK,aAAa;gBACpCX,eAAeQ,IAAI,CAAC;YACtB,OAAO,IAAIN,KAAKS,IAAI,KAAK,OAAO;gBAC9BX,eAAeQ,IAAI,CAAC;YACtB,OAAO,IAAI,UAAUN,QAAQA,KAAKW,IAAI,EAAE;gBACtCb,eAAeQ,IAAI,CAACN,KAAKW,IAAI;YAC/B;YAEA,IAAI,cAAcX,QAAQA,KAAKL,QAAQ,EAAE;gBACvCG,eAAeQ,IAAI,IACdd,+BAA+B;oBAChCH;oBACAI,OAAOO,KAAKL,QAAQ;oBACpBC,QAAQI;gBACV;YAEJ;QACF;IACF;IAEA,OAAOF,eAAec,MAAM,CAACC;AAC/B"}
+{"version":3,"file":"index.js","names":["hasText","findConverterForNode","convertLexicalToPlaintext","converters","data","plaintext","convertLexicalNodesToPlaintext","nodes","root","children","parent","join","plainTextArray","i","node","converter","converted","childIndex","nodesToPlaintext","args","push","error","console","type","length","text","filter","Boolean"],"sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/index.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nimport type { PlaintextConverters } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\n\nexport type ConvertLexicalToPlaintextArgs = {\n  /**\n   * A map of node types to their corresponding plaintext converter functions.\n   * This is optional - if not provided, the following heuristic will be used:\n   *\n   * - If the node has a `text` property, it will be used as the plaintext.\n   * - If the node has a `children` property, the children will be recursively converted to plaintext.\n   * - If the node has neither, it will be ignored.\n   **/\n  converters?: PlaintextConverters\n  data: SerializedEditorState\n}\n\nexport function convertLexicalToPlaintext({\n  converters,\n  data,\n}: ConvertLexicalToPlaintextArgs): string {\n  if (hasText(data)) {\n    const plaintext = convertLexicalNodesToPlaintext({\n      converters: converters ?? {},\n      nodes: data?.root?.children,\n      parent: data?.root,\n    }).join('')\n\n    return plaintext\n  }\n  return ''\n}\n\nexport function convertLexicalNodesToPlaintext({\n  converters,\n  nodes,\n  parent,\n}: {\n  converters: PlaintextConverters\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): string[] {\n  const plainTextArray: string[] = []\n\n  let i = -1\n  for (const node of nodes) {\n    i++\n\n    const converter = findConverterForNode({\n      converters,\n      node,\n    })\n\n    if (converter) {\n      try {\n        const converted =\n          typeof converter === 'function'\n            ? converter({\n                childIndex: i,\n                converters,\n                node,\n                nodesToPlaintext: (args) => {\n                  return convertLexicalNodesToPlaintext({\n                    converters: args.converters ?? converters,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                  })\n                },\n                parent,\n              })\n            : converter\n\n        if (converted && typeof converted === 'string') {\n          plainTextArray.push(converted)\n        }\n      } catch (error) {\n        console.error('Error converting lexical node to plaintext:', error, 'node:', node)\n      }\n    } else {\n      // Default plaintext converter heuristic\n      if (\n        node.type === 'paragraph' ||\n        node.type === 'heading' ||\n        node.type === 'list' ||\n        node.type === 'table'\n      ) {\n        if (plainTextArray?.length) {\n          // Only add a new line if there is already text in the array\n          plainTextArray.push('\\n\\n')\n        }\n      } else if (node.type === 'listitem' || node.type === 'tablerow') {\n        if (plainTextArray?.length) {\n          // Only add a new line if there is already text in the array\n          plainTextArray.push('\\n')\n        }\n      } else if (node.type === 'tablecell') {\n        if (plainTextArray?.length) {\n          plainTextArray.push(' | ')\n        }\n      } else if (node.type === 'linebreak') {\n        plainTextArray.push('\\n')\n      } else if (node.type === 'tab') {\n        plainTextArray.push('\\t')\n      } else if ('text' in node && node.text) {\n        plainTextArray.push(node.text as string)\n      }\n\n      if ('children' in node && node.children) {\n        plainTextArray.push(\n          ...convertLexicalNodesToPlaintext({\n            converters,\n            nodes: node.children as SerializedLexicalNode[],\n            parent: node,\n          }),\n        )\n      }\n    }\n  }\n\n  return plainTextArray.filter(Boolean)\n}\n"],"mappings":"AAAA,+BAMA,SAASA,OAAO,QAAQ;AACxB,SAASC,oBAAoB,QAAQ;AAerC,OAAO,SAASC,0BAA0B;EACxCC,UAAU;EACVC;AAAI,CAC0B;EAC9B,IAAIJ,OAAA,CAAQI,IAAA,GAAO;IACjB,MAAMC,SAAA,GAAYC,8BAAA,CAA+B;MAC/CH,UAAA,EAAYA,UAAA,IAAc,CAAC;MAC3BI,KAAA,EAAOH,IAAA,EAAMI,IAAA,EAAMC,QAAA;MACnBC,MAAA,EAAQN,IAAA,EAAMI;IAChB,GAAGG,IAAI,CAAC;IAER,OAAON,SAAA;EACT;EACA,OAAO;AACT;AAEA,OAAO,SAASC,+BAA+B;EAC7CH,UAAU;EACVI,KAAK;EACLG;AAAM,CAKP;EACC,MAAME,cAAA,GAA2B,EAAE;EAEnC,IAAIC,CAAA,GAAI,CAAC;EACT,KAAK,MAAMC,IAAA,IAAQP,KAAA,EAAO;IACxBM,CAAA;IAEA,MAAME,SAAA,GAAYd,oBAAA,CAAqB;MACrCE,UAAA;MACAW;IACF;IAEA,IAAIC,SAAA,EAAW;MACb,IAAI;QACF,MAAMC,SAAA,GACJ,OAAOD,SAAA,KAAc,aACjBA,SAAA,CAAU;UACRE,UAAA,EAAYJ,CAAA;UACZV,UAAA;UACAW,IAAA;UACAI,gBAAA,EAAmBC,IAAA;YACjB,OAAOb,8BAAA,CAA+B;cACpCH,UAAA,EAAYgB,IAAA,CAAKhB,UAAU,IAAIA,UAAA;cAC/BI,KAAA,EAAOY,IAAA,CAAKZ,KAAK;cACjBG,MAAA,EAAQS,IAAA,CAAKT,MAAM,IAAI;gBACrB,GAAGI,IAAI;gBACPJ;cACF;YACF;UACF;UACAA;QACF,KACAK,SAAA;QAEN,IAAIC,SAAA,IAAa,OAAOA,SAAA,KAAc,UAAU;UAC9CJ,cAAA,CAAeQ,IAAI,CAACJ,SAAA;QACtB;MACF,EAAE,OAAOK,KAAA,EAAO;QACdC,OAAA,CAAQD,KAAK,CAAC,+CAA+CA,KAAA,EAAO,SAASP,IAAA;MAC/E;IACF,OAAO;MACL;MACA,IACEA,IAAA,CAAKS,IAAI,KAAK,eACdT,IAAA,CAAKS,IAAI,KAAK,aACdT,IAAA,CAAKS,IAAI,KAAK,UACdT,IAAA,CAAKS,IAAI,KAAK,SACd;QACA,IAAIX,cAAA,EAAgBY,MAAA,EAAQ;UAC1B;UACAZ,cAAA,CAAeQ,IAAI,CAAC;QACtB;MACF,OAAO,IAAIN,IAAA,CAAKS,IAAI,KAAK,cAAcT,IAAA,CAAKS,IAAI,KAAK,YAAY;QAC/D,IAAIX,cAAA,EAAgBY,MAAA,EAAQ;UAC1B;UACAZ,cAAA,CAAeQ,IAAI,CAAC;QACtB;MACF,OAAO,IAAIN,IAAA,CAAKS,IAAI,KAAK,aAAa;QACpC,IAAIX,cAAA,EAAgBY,MAAA,EAAQ;UAC1BZ,cAAA,CAAeQ,IAAI,CAAC;QACtB;MACF,OAAO,IAAIN,IAAA,CAAKS,IAAI,KAAK,aAAa;QACpCX,cAAA,CAAeQ,IAAI,CAAC;MACtB,OAAO,IAAIN,IAAA,CAAKS,IAAI,KAAK,OAAO;QAC9BX,cAAA,CAAeQ,IAAI,CAAC;MACtB,OAAO,IAAI,UAAUN,IAAA,IAAQA,IAAA,CAAKW,IAAI,EAAE;QACtCb,cAAA,CAAeQ,IAAI,CAACN,IAAA,CAAKW,IAAI;MAC/B;MAEA,IAAI,cAAcX,IAAA,IAAQA,IAAA,CAAKL,QAAQ,EAAE;QACvCG,cAAA,CAAeQ,IAAI,IACdd,8BAAA,CAA+B;UAChCH,UAAA;UACAI,KAAA,EAAOO,IAAA,CAAKL,QAAQ;UACpBC,MAAA,EAAQI;QACV;MAEJ;IACF;EACF;EAEA,OAAOF,cAAA,CAAec,MAAM,CAACC,OAAA;AAC/B","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/sync/types.js

@@ -1,4 +1,2 @@
-// need these to ensure types for blocks and inlineBlocks work if no generics are provided
-export { };
-
+export {};
 //# sourceMappingURL=types.js.map

package/dist/features/converters/lexicalToPlaintext/sync/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\n\nexport type PlaintextConverter<\n  T extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> =\n  | ((args: {\n      childIndex: number\n      converters: PlaintextConverters\n      node: T\n      nodesToPlaintext: (args: {\n        converters?: PlaintextConverters\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => string[]\n      parent: SerializedLexicalNodeWithParent\n    }) => string)\n  | string\n\nexport type DefaultPlaintextNodeTypes =\n  | DefaultNodeTypes\n  | SerializedBlockNode<{ blockName?: null | string; blockType: string }> // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n  | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>\n\nexport type PlaintextConverters<\n  T extends { [key: string]: any; type?: string } = DefaultPlaintextNodeTypes,\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: PlaintextConverter<any>\n      }\n    | PlaintextConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: PlaintextConverter<\n    Extract<T, { type: nodeType }>\n  >\n} & {\n  blocks?: {\n    [K in Extract<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: PlaintextConverter<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? SerializedBlockNode<Extract<B, { blockType: K }>>\n        : SerializedBlockNode\n    >\n  }\n  inlineBlocks?: {\n    [K in Extract<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: PlaintextConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n}\n"],"names":[],"mappings":"AA2B0E,0FAA0F;AAGpK,WA0CC"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\n\nexport type PlaintextConverter<\n  T extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> =\n  | ((args: {\n      childIndex: number\n      converters: PlaintextConverters\n      node: T\n      nodesToPlaintext: (args: {\n        converters?: PlaintextConverters\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => string[]\n      parent: SerializedLexicalNodeWithParent\n    }) => string)\n  | string\n\nexport type DefaultPlaintextNodeTypes =\n  | DefaultNodeTypes\n  | SerializedBlockNode<{ blockName?: null | string; blockType: string }> // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n  | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>\n\nexport type PlaintextConverters<\n  T extends { [key: string]: any; type?: string } = DefaultPlaintextNodeTypes,\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: PlaintextConverter<any>\n      }\n    | PlaintextConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: PlaintextConverter<\n    Extract<T, { type: nodeType }>\n  >\n} & {\n  blocks?: {\n    [K in Extract<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: PlaintextConverter<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? SerializedBlockNode<Extract<B, { blockType: K }>>\n        : SerializedBlockNode\n    >\n  }\n  inlineBlocks?: {\n    [K in Extract<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: PlaintextConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n}\n"],"mappings":"AA8BA","ignoreList":[]}

package/dist/features/converters/markdownToLexical/index.js

@@ -1,19 +1,21 @@
 import { createHeadlessEditor } from '@lexical/headless';
 import { getEnabledNodes } from '../../../lexical/nodes/index.js';
 import { $convertFromMarkdownString } from '../../../packages/@lexical/markdown/index.js';
-export const convertMarkdownToLexical = ({ editorConfig, markdown })=>{
-    const headlessEditor = createHeadlessEditor({
-        nodes: getEnabledNodes({
-            editorConfig
-        })
-    });
-    headlessEditor.update(()=>{
-        $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers);
-    }, {
-        discrete: true
-    });
-    const editorJSON = headlessEditor.getEditorState().toJSON();
-    return editorJSON;
+export const convertMarkdownToLexical = ({
+  editorConfig,
+  markdown
+}) => {
+  const headlessEditor = createHeadlessEditor({
+    nodes: getEnabledNodes({
+      editorConfig
+    })
+  });
+  headlessEditor.update(() => {
+    $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers);
+  }, {
+    discrete: true
+  });
+  const editorJSON = headlessEditor.getEditorState().toJSON();
+  return editorJSON;
 };
-
 //# sourceMappingURL=index.js.map

package/dist/features/converters/markdownToLexical/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/converters/markdownToLexical/index.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js'\nimport type { DefaultNodeTypes, TypedEditorState } from '../../../nodeTypes.js'\n\nimport { getEnabledNodes } from '../../../lexical/nodes/index.js'\nimport { $convertFromMarkdownString } from '../../../packages/@lexical/markdown/index.js'\n\nexport const convertMarkdownToLexical = <\n  TNodeTypes extends SerializedLexicalNode = DefaultNodeTypes,\n>({\n  editorConfig,\n  markdown,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n  markdown: string\n}): TypedEditorState<TNodeTypes> => {\n  const headlessEditor = createHeadlessEditor({\n    nodes: getEnabledNodes({\n      editorConfig,\n    }),\n  })\n\n  headlessEditor.update(\n    () => {\n      $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers)\n    },\n    { discrete: true },\n  )\n\n  const editorJSON = headlessEditor.getEditorState().toJSON()\n\n  return editorJSON as TypedEditorState<TNodeTypes>\n}\n"],"names":["createHeadlessEditor","getEnabledNodes","$convertFromMarkdownString","convertMarkdownToLexical","editorConfig","markdown","headlessEditor","nodes","update","features","markdownTransformers","discrete","editorJSON","getEditorState","toJSON"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ,oBAAmB;AAKxD,SAASC,eAAe,QAAQ,kCAAiC;AACjE,SAASC,0BAA0B,QAAQ,+CAA8C;AAEzF,OAAO,MAAMC,2BAA2B,CAEtC,EACAC,YAAY,EACZC,QAAQ,EAIT;IACC,MAAMC,iBAAiBN,qBAAqB;QAC1CO,OAAON,gBAAgB;YACrBG;QACF;IACF;IAEAE,eAAeE,MAAM,CACnB;QACEN,2BAA2BG,UAAUD,aAAaK,QAAQ,CAACC,oBAAoB;IACjF,GACA;QAAEC,UAAU;IAAK;IAGnB,MAAMC,aAAaN,eAAeO,cAAc,GAAGC,MAAM;IAEzD,OAAOF;AACT,EAAC"}
+{"version":3,"file":"index.js","names":["createHeadlessEditor","getEnabledNodes","$convertFromMarkdownString","convertMarkdownToLexical","editorConfig","markdown","headlessEditor","nodes","update","features","markdownTransformers","discrete","editorJSON","getEditorState","toJSON"],"sources":["../../../../src/features/converters/markdownToLexical/index.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js'\nimport type { DefaultNodeTypes, TypedEditorState } from '../../../nodeTypes.js'\n\nimport { getEnabledNodes } from '../../../lexical/nodes/index.js'\nimport { $convertFromMarkdownString } from '../../../packages/@lexical/markdown/index.js'\n\nexport const convertMarkdownToLexical = <\n  TNodeTypes extends SerializedLexicalNode = DefaultNodeTypes,\n>({\n  editorConfig,\n  markdown,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n  markdown: string\n}): TypedEditorState<TNodeTypes> => {\n  const headlessEditor = createHeadlessEditor({\n    nodes: getEnabledNodes({\n      editorConfig,\n    }),\n  })\n\n  headlessEditor.update(\n    () => {\n      $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers)\n    },\n    { discrete: true },\n  )\n\n  const editorJSON = headlessEditor.getEditorState().toJSON()\n\n  return editorJSON as TypedEditorState<TNodeTypes>\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAKrC,SAASC,eAAe,QAAQ;AAChC,SAASC,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,wBAAA,GAA2BA,CAEtC;EACAC,YAAY;EACZC;AAAQ,CAIT;EACC,MAAMC,cAAA,GAAiBN,oBAAA,CAAqB;IAC1CO,KAAA,EAAON,eAAA,CAAgB;MACrBG;IACF;EACF;EAEAE,cAAA,CAAeE,MAAM,CACnB;IACEN,0BAAA,CAA2BG,QAAA,EAAUD,YAAA,CAAaK,QAAQ,CAACC,oBAAoB;EACjF,GACA;IAAEC,QAAA,EAAU;EAAK;EAGnB,MAAMC,UAAA,GAAaN,cAAA,CAAeO,cAAc,GAAGC,MAAM;EAEzD,OAAOF,UAAA;AACT","ignoreList":[]}

package/dist/features/converters/utilities/payloadPopulateFn.js

@@ -1,41 +1,42 @@
 import { createLocalReq } from 'payload';
 import { populate } from '../../../populateGraphQL/populate.js';
-export const getPayloadPopulateFn = /**
-         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.
-         */ /**
-         * When the converter is called, req CAN be passed in depending on where it's run.
-         * If this is undefined and config is passed through, lexical will create a new req object for you.
-         */ /**
-         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.
-         */ /**
-         * When the converter is called, req CAN be passed in depending on where it's run.
-         * If this is undefined and config is passed through, lexical will create a new req object for you.
-         */ async ({ currentDepth, depth, draft, overrideAccess, payload, req, showHiddenFields })=>{
-    let reqToUse = req;
-    if (req === undefined && payload) {
-        reqToUse = await createLocalReq({}, payload);
-    }
-    if (!reqToUse) {
-        throw new Error('No req or payload provided');
-    }
-    const populateFn = async ({ id, collectionSlug, select })=>{
-        const dataContainer = {};
-        await populate({
-            id,
-            collectionSlug,
-            currentDepth,
-            data: dataContainer,
-            depth,
-            draft: draft ?? false,
-            key: 'value',
-            overrideAccess: overrideAccess ?? true,
-            req: reqToUse,
-            select,
-            showHiddenFields: showHiddenFields ?? false
-        });
-        return dataContainer.value;
-    };
-    return populateFn;
+export const getPayloadPopulateFn = async ({
+  currentDepth,
+  depth,
+  draft,
+  overrideAccess,
+  payload,
+  req,
+  showHiddenFields
+}) => {
+  let reqToUse = req;
+  if (req === undefined && payload) {
+    reqToUse = await createLocalReq({}, payload);
+  }
+  if (!reqToUse) {
+    throw new Error('No req or payload provided');
+  }
+  const populateFn = async ({
+    id,
+    collectionSlug,
+    select
+  }) => {
+    const dataContainer = {};
+    await populate({
+      id,
+      collectionSlug,
+      currentDepth,
+      data: dataContainer,
+      depth,
+      draft: draft ?? false,
+      key: 'value',
+      overrideAccess: overrideAccess ?? true,
+      req: reqToUse,
+      select,
+      showHiddenFields: showHiddenFields ?? false
+    });
+    return dataContainer.value;
+  };
+  return populateFn;
 };
-
 //# sourceMappingURL=payloadPopulateFn.js.map

package/dist/features/converters/utilities/payloadPopulateFn.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/converters/utilities/payloadPopulateFn.ts"],"sourcesContent":["import { createLocalReq, type Payload, type PayloadRequest, type TypedLocale } from 'payload'\n\nimport type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js'\n\nimport { populate } from '../../../populateGraphQL/populate.js'\n\nexport const getPayloadPopulateFn: (\n  args: {\n    currentDepth: number\n    depth: number\n    draft?: boolean\n    locale?: TypedLocale\n\n    overrideAccess?: boolean\n    showHiddenFields?: boolean\n  } & (\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload: Payload\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req?: never\n      }\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload?: never\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req: PayloadRequest\n      }\n  ),\n) => Promise<HTMLPopulateFn> = async ({\n  currentDepth,\n  depth,\n  draft,\n  overrideAccess,\n  payload,\n  req,\n  showHiddenFields,\n}) => {\n  let reqToUse: PayloadRequest | undefined = req\n  if (req === undefined && payload) {\n    reqToUse = await createLocalReq({}, payload)\n  }\n\n  if (!reqToUse) {\n    throw new Error('No req or payload provided')\n  }\n\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const dataContainer: {\n      value?: any\n    } = {}\n\n    await populate({\n      id,\n      collectionSlug,\n      currentDepth,\n      data: dataContainer,\n      depth,\n      draft: draft ?? false,\n      key: 'value',\n      overrideAccess: overrideAccess ?? true,\n      req: reqToUse,\n      select,\n      showHiddenFields: showHiddenFields ?? false,\n    })\n\n    return dataContainer.value\n  }\n\n  return populateFn\n}\n"],"names":["createLocalReq","populate","getPayloadPopulateFn","currentDepth","depth","draft","overrideAccess","payload","req","showHiddenFields","reqToUse","undefined","Error","populateFn","id","collectionSlug","select","dataContainer","data","key","value"],"mappings":"AAAA,SAASA,cAAc,QAA6D,UAAS;AAI7F,SAASC,QAAQ,QAAQ,uCAAsC;AAE/D,OAAO,MAAMC,uBAWL;;SAEC,GAED;;;SAGC,GAID;;SAEC,GAED;;;SAGC,GAIsB,OAAO,EACpCC,YAAY,EACZC,KAAK,EACLC,KAAK,EACLC,cAAc,EACdC,OAAO,EACPC,GAAG,EACHC,gBAAgB,EACjB;IACC,IAAIC,WAAuCF;IAC3C,IAAIA,QAAQG,aAAaJ,SAAS;QAChCG,WAAW,MAAMV,eAAe,CAAC,GAAGO;IACtC;IAEA,IAAI,CAACG,UAAU;QACb,MAAM,IAAIE,MAAM;IAClB;IAEA,MAAMC,aAA6B,OAAO,EAAEC,EAAE,EAAEC,cAAc,EAAEC,MAAM,EAAE;QACtE,MAAMC,gBAEF,CAAC;QAEL,MAAMhB,SAAS;YACba;YACAC;YACAZ;YACAe,MAAMD;YACNb;YACAC,OAAOA,SAAS;YAChBc,KAAK;YACLb,gBAAgBA,kBAAkB;YAClCE,KAAKE;YACLM;YACAP,kBAAkBA,oBAAoB;QACxC;QAEA,OAAOQ,cAAcG,KAAK;IAC5B;IAEA,OAAOP;AACT,EAAC"}
+{"version":3,"file":"payloadPopulateFn.js","names":["createLocalReq","populate","getPayloadPopulateFn","currentDepth","depth","draft","overrideAccess","payload","req","showHiddenFields","reqToUse","undefined","Error","populateFn","id","collectionSlug","select","dataContainer","data","key","value"],"sources":["../../../../src/features/converters/utilities/payloadPopulateFn.ts"],"sourcesContent":["import { createLocalReq, type Payload, type PayloadRequest, type TypedLocale } from 'payload'\n\nimport type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js'\n\nimport { populate } from '../../../populateGraphQL/populate.js'\n\nexport const getPayloadPopulateFn: (\n  args: {\n    currentDepth: number\n    depth: number\n    draft?: boolean\n    locale?: TypedLocale\n\n    overrideAccess?: boolean\n    showHiddenFields?: boolean\n  } & (\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload: Payload\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req?: never\n      }\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload?: never\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req: PayloadRequest\n      }\n  ),\n) => Promise<HTMLPopulateFn> = async ({\n  currentDepth,\n  depth,\n  draft,\n  overrideAccess,\n  payload,\n  req,\n  showHiddenFields,\n}) => {\n  let reqToUse: PayloadRequest | undefined = req\n  if (req === undefined && payload) {\n    reqToUse = await createLocalReq({}, payload)\n  }\n\n  if (!reqToUse) {\n    throw new Error('No req or payload provided')\n  }\n\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const dataContainer: {\n      value?: any\n    } = {}\n\n    await populate({\n      id,\n      collectionSlug,\n      currentDepth,\n      data: dataContainer,\n      depth,\n      draft: draft ?? false,\n      key: 'value',\n      overrideAccess: overrideAccess ?? true,\n      req: reqToUse,\n      select,\n      showHiddenFields: showHiddenFields ?? false,\n    })\n\n    return dataContainer.value\n  }\n\n  return populateFn\n}\n"],"mappings":"AAAA,SAASA,cAAc,QAA6D;AAIpF,SAASC,QAAQ,QAAQ;AAEzB,OAAO,MAAMC,oBAAA,GAiCkB,MAAAA,CAAO;EACpCC,YAAY;EACZC,KAAK;EACLC,KAAK;EACLC,cAAc;EACdC,OAAO;EACPC,GAAG;EACHC;AAAgB,CACjB;EACC,IAAIC,QAAA,GAAuCF,GAAA;EAC3C,IAAIA,GAAA,KAAQG,SAAA,IAAaJ,OAAA,EAAS;IAChCG,QAAA,GAAW,MAAMV,cAAA,CAAe,CAAC,GAAGO,OAAA;EACtC;EAEA,IAAI,CAACG,QAAA,EAAU;IACb,MAAM,IAAIE,KAAA,CAAM;EAClB;EAEA,MAAMC,UAAA,GAA6B,MAAAA,CAAO;IAAEC,EAAE;IAAEC,cAAc;IAAEC;EAAM,CAAE;IACtE,MAAMC,aAAA,GAEF,CAAC;IAEL,MAAMhB,QAAA,CAAS;MACba,EAAA;MACAC,cAAA;MACAZ,YAAA;MACAe,IAAA,EAAMD,aAAA;MACNb,KAAA;MACAC,KAAA,EAAOA,KAAA,IAAS;MAChBc,GAAA,EAAK;MACLb,cAAA,EAAgBA,cAAA,IAAkB;MAClCE,GAAA,EAAKE,QAAA;MACLM,MAAA;MACAP,gBAAA,EAAkBA,gBAAA,IAAoB;IACxC;IAEA,OAAOQ,aAAA,CAAcG,KAAK;EAC5B;EAEA,OAAOP,UAAA;AACT","ignoreList":[]}

package/dist/features/converters/utilities/restPopulateFn.js

@@ -1,27 +1,33 @@
 import { stringify } from 'qs-esm';
-export const getRestPopulateFn = /**
-   * E.g. `http://localhost:3000/api`
-   */ ({ apiURL, depth, draft, locale })=>{
-    const populateFn = async ({ id, collectionSlug, select })=>{
-        const query = stringify({
-            depth: depth ?? 0,
-            draft: draft ?? false,
-            locale,
-            select
-        }, {
-            addQueryPrefix: true
-        });
-        const res = await fetch(`${apiURL}/${collectionSlug}/${id}${query}`, {
-            credentials: 'include',
-            headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json'
-            },
-            method: 'GET'
-        }).then((res)=>res.json());
-        return res;
-    };
-    return populateFn;
+export const getRestPopulateFn = ({
+  apiURL,
+  depth,
+  draft,
+  locale
+}) => {
+  const populateFn = async ({
+    id,
+    collectionSlug,
+    select
+  }) => {
+    const query = stringify({
+      depth: depth ?? 0,
+      draft: draft ?? false,
+      locale,
+      select
+    }, {
+      addQueryPrefix: true
+    });
+    const res = await fetch(`${apiURL}/${collectionSlug}/${id}${query}`, {
+      credentials: 'include',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      },
+      method: 'GET'
+    }).then(res => res.json());
+    return res;
+  };
+  return populateFn;
 };
-
 //# sourceMappingURL=restPopulateFn.js.map

package/dist/features/converters/utilities/restPopulateFn.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/converters/utilities/restPopulateFn.ts"],"sourcesContent":["import { stringify } from 'qs-esm'\n\nimport type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js'\n\nexport const getRestPopulateFn: (args: {\n  /**\n   * E.g. `http://localhost:3000/api`\n   */\n  apiURL: string\n  depth?: number\n  draft?: boolean\n  locale?: string\n}) => HTMLPopulateFn = ({ apiURL, depth, draft, locale }) => {\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const query = stringify(\n      { depth: depth ?? 0, draft: draft ?? false, locale, select },\n      { addQueryPrefix: true },\n    )\n\n    const res = await fetch(`${apiURL}/${collectionSlug}/${id}${query}`, {\n      credentials: 'include',\n      headers: {\n        Accept: 'application/json',\n        'Content-Type': 'application/json',\n      },\n      method: 'GET',\n    }).then((res) => res.json())\n\n    return res\n  }\n\n  return populateFn\n}\n"],"names":["stringify","getRestPopulateFn","apiURL","depth","draft","locale","populateFn","id","collectionSlug","select","query","addQueryPrefix","res","fetch","credentials","headers","Accept","method","then","json"],"mappings":"AAAA,SAASA,SAAS,QAAQ,SAAQ;AAIlC,OAAO,MAAMC,oBACX;;GAEC,GAKoB,CAAC,EAAEC,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,MAAM,EAAE;IACtD,MAAMC,aAA6B,OAAO,EAAEC,EAAE,EAAEC,cAAc,EAAEC,MAAM,EAAE;QACtE,MAAMC,QAAQV,UACZ;YAAEG,OAAOA,SAAS;YAAGC,OAAOA,SAAS;YAAOC;YAAQI;QAAO,GAC3D;YAAEE,gBAAgB;QAAK;QAGzB,MAAMC,MAAM,MAAMC,MAAM,GAAGX,OAAO,CAAC,EAAEM,eAAe,CAAC,EAAED,KAAKG,OAAO,EAAE;YACnEI,aAAa;YACbC,SAAS;gBACPC,QAAQ;gBACR,gBAAgB;YAClB;YACAC,QAAQ;QACV,GAAGC,IAAI,CAAC,CAACN,MAAQA,IAAIO,IAAI;QAEzB,OAAOP;IACT;IAEA,OAAON;AACT,EAAC"}
+{"version":3,"file":"restPopulateFn.js","names":["stringify","getRestPopulateFn","apiURL","depth","draft","locale","populateFn","id","collectionSlug","select","query","addQueryPrefix","res","fetch","credentials","headers","Accept","method","then","json"],"sources":["../../../../src/features/converters/utilities/restPopulateFn.ts"],"sourcesContent":["import { stringify } from 'qs-esm'\n\nimport type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js'\n\nexport const getRestPopulateFn: (args: {\n  /**\n   * E.g. `http://localhost:3000/api`\n   */\n  apiURL: string\n  depth?: number\n  draft?: boolean\n  locale?: string\n}) => HTMLPopulateFn = ({ apiURL, depth, draft, locale }) => {\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const query = stringify(\n      { depth: depth ?? 0, draft: draft ?? false, locale, select },\n      { addQueryPrefix: true },\n    )\n\n    const res = await fetch(`${apiURL}/${collectionSlug}/${id}${query}`, {\n      credentials: 'include',\n      headers: {\n        Accept: 'application/json',\n        'Content-Type': 'application/json',\n      },\n      method: 'GET',\n    }).then((res) => res.json())\n\n    return res\n  }\n\n  return populateFn\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ;AAI1B,OAAO,MAAMC,iBAAA,GAQUA,CAAC;EAAEC,MAAM;EAAEC,KAAK;EAAEC,KAAK;EAAEC;AAAM,CAAE;EACtD,MAAMC,UAAA,GAA6B,MAAAA,CAAO;IAAEC,EAAE;IAAEC,cAAc;IAAEC;EAAM,CAAE;IACtE,MAAMC,KAAA,GAAQV,SAAA,CACZ;MAAEG,KAAA,EAAOA,KAAA,IAAS;MAAGC,KAAA,EAAOA,KAAA,IAAS;MAAOC,MAAA;MAAQI;IAAO,GAC3D;MAAEE,cAAA,EAAgB;IAAK;IAGzB,MAAMC,GAAA,GAAM,MAAMC,KAAA,CAAM,GAAGX,MAAA,IAAUM,cAAA,IAAkBD,EAAA,GAAKG,KAAA,EAAO,EAAE;MACnEI,WAAA,EAAa;MACbC,OAAA,EAAS;QACPC,MAAA,EAAQ;QACR,gBAAgB;MAClB;MACAC,MAAA,EAAQ;IACV,GAAGC,IAAI,CAAEN,GAAA,IAAQA,GAAA,CAAIO,IAAI;IAEzB,OAAOP,GAAA;EACT;EAEA,OAAON,UAAA;AACT","ignoreList":[]}

package/dist/features/debug/jsxConverter/client/index.js

@@ -1,13 +1,11 @@
 'use client';
+
 import { createClientFeature } from '../../../../utilities/createClientFeature.js';
 import { RichTextPlugin } from './plugin/index.js';
 export const DebugJsxConverterFeatureClient = createClientFeature({
-    plugins: [
-        {
-            Component: RichTextPlugin,
-            position: 'bottom'
-        }
-    ]
+  plugins: [{
+    Component: RichTextPlugin,
+    position: 'bottom'
+  }]
 });
-
 //# sourceMappingURL=index.js.map

package/dist/features/debug/jsxConverter/client/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/debug/jsxConverter/client/index.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../../utilities/createClientFeature.js'\nimport { RichTextPlugin } from './plugin/index.js'\n\nexport const DebugJsxConverterFeatureClient = createClientFeature({\n  plugins: [\n    {\n      Component: RichTextPlugin,\n      position: 'bottom',\n    },\n  ],\n})\n"],"names":["createClientFeature","RichTextPlugin","DebugJsxConverterFeatureClient","plugins","Component","position"],"mappings":"AAAA;AAEA,SAASA,mBAAmB,QAAQ,+CAA8C;AAClF,SAASC,cAAc,QAAQ,oBAAmB;AAElD,OAAO,MAAMC,iCAAiCF,oBAAoB;IAChEG,SAAS;QACP;YACEC,WAAWH;YACXI,UAAU;QACZ;KACD;AACH,GAAE"}
+{"version":3,"file":"index.js","names":["createClientFeature","RichTextPlugin","DebugJsxConverterFeatureClient","plugins","Component","position"],"sources":["../../../../../src/features/debug/jsxConverter/client/index.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../../utilities/createClientFeature.js'\nimport { RichTextPlugin } from './plugin/index.js'\n\nexport const DebugJsxConverterFeatureClient = createClientFeature({\n  plugins: [\n    {\n      Component: RichTextPlugin,\n      position: 'bottom',\n    },\n  ],\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,cAAc,QAAQ;AAE/B,OAAO,MAAMC,8BAAA,GAAiCF,mBAAA,CAAoB;EAChEG,OAAA,EAAS,CACP;IACEC,SAAA,EAAWH,cAAA;IACXI,QAAA,EAAU;EACZ;AAEJ","ignoreList":[]}

package/dist/features/debug/jsxConverter/client/plugin/index.js

@@ -1,35 +1,55 @@
 'use client';
-import { jsxDEV as _jsxDEV } from "react/jsx-dev-runtime";
+
+import { c as _c } from "react/compiler-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
 import { useEffect, useState } from 'react';
 // eslint-disable-next-line payload/no-imports-from-exports-dir
 import { defaultJSXConverters, RichText } from '../../../../../exports/react/index.js';
-import './style.scss';
 export function RichTextPlugin() {
-    const [editor] = useLexicalComposerContext();
-    const [editorState, setEditorState] = useState(editor.getEditorState().toJSON());
-    useEffect(()=>{
-        return editor.registerUpdateListener(({ editorState })=>{
-            setEditorState(editorState.toJSON());
-        });
-    }, [
-        editor
-    ]);
-    return /*#__PURE__*/ _jsxDEV("div", {
-        className: "debug-jsx-converter",
-        children: /*#__PURE__*/ _jsxDEV(RichText, {
-            converters: defaultJSXConverters,
-            data: editorState
-        }, void 0, false, {
-            fileName: "src/features/debug/jsxConverter/client/plugin/index.tsx",
-            lineNumber: 22,
-            columnNumber: 7
-        }, this)
-    }, void 0, false, {
-        fileName: "src/features/debug/jsxConverter/client/plugin/index.tsx",
-        lineNumber: 21,
-        columnNumber: 5
-    }, this);
+  const $ = _c(7);
+  const [editor] = useLexicalComposerContext();
+  let t0;
+  if ($[0] !== editor) {
+    t0 = editor.getEditorState().toJSON();
+    $[0] = editor;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const [editorState, setEditorState] = useState(t0);
+  let t1;
+  let t2;
+  if ($[2] !== editor) {
+    t1 = () => editor.registerUpdateListener(t3 => {
+      const {
+        editorState: editorState_0
+      } = t3;
+      setEditorState(editorState_0.toJSON());
+    });
+    t2 = [editor];
+    $[2] = editor;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[5] !== editorState) {
+    t3 = _jsx("div", {
+      className: "debug-jsx-converter",
+      children: _jsx(RichText, {
+        converters: defaultJSXConverters,
+        data: editorState
+      })
+    });
+    $[5] = editorState;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  return t3;
 }
-
 //# sourceMappingURL=index.js.map

package/dist/features/debug/jsxConverter/client/plugin/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/debug/jsxConverter/client/plugin/index.tsx"],"sourcesContent":["'use client'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useEffect, useState } from 'react'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { defaultJSXConverters, RichText } from '../../../../../exports/react/index.js'\nimport './style.scss'\n\nexport function RichTextPlugin() {\n  const [editor] = useLexicalComposerContext()\n  const [editorState, setEditorState] = useState(editor.getEditorState().toJSON())\n\n  useEffect(() => {\n    return editor.registerUpdateListener(({ editorState }) => {\n      setEditorState(editorState.toJSON())\n    })\n  }, [editor])\n\n  return (\n    <div className=\"debug-jsx-converter\">\n      <RichText converters={defaultJSXConverters} data={editorState} />\n    </div>\n  )\n}\n"],"names":["useLexicalComposerContext","useEffect","useState","defaultJSXConverters","RichText","RichTextPlugin","editor","editorState","setEditorState","getEditorState","toJSON","registerUpdateListener","div","className","converters","data"],"mappings":"AAAA;;AAEA,SAASA,yBAAyB,QAAQ,wCAAuC;AACjF,SAASC,SAAS,EAAEC,QAAQ,QAAQ,QAAO;AAE3C,+DAA+D;AAC/D,SAASC,oBAAoB,EAAEC,QAAQ,QAAQ,wCAAuC;AACtF,OAAO,eAAc;AAErB,OAAO,SAASC;IACd,MAAM,CAACC,OAAO,GAAGN;IACjB,MAAM,CAACO,aAAaC,eAAe,GAAGN,SAASI,OAAOG,cAAc,GAAGC,MAAM;IAE7ET,UAAU;QACR,OAAOK,OAAOK,sBAAsB,CAAC,CAAC,EAAEJ,WAAW,EAAE;YACnDC,eAAeD,YAAYG,MAAM;QACnC;IACF,GAAG;QAACJ;KAAO;IAEX,qBACE,QAACM;QAAIC,WAAU;kBACb,cAAA,QAACT;YAASU,YAAYX;YAAsBY,MAAMR;;;;;;;;;;;AAGxD"}
+{"version":3,"file":"index.js","names":["c","_c","useLexicalComposerContext","useEffect","useState","defaultJSXConverters","RichText","RichTextPlugin","$","editor","t0","getEditorState","toJSON","editorState","setEditorState","t1","t2","registerUpdateListener","t3","editorState_0","_jsx","className","children","converters","data"],"sources":["../../../../../../src/features/debug/jsxConverter/client/plugin/index.tsx"],"sourcesContent":["'use client'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useEffect, useState } from 'react'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { defaultJSXConverters, RichText } from '../../../../../exports/react/index.js'\nimport './style.scss'\n\nexport function RichTextPlugin() {\n  const [editor] = useLexicalComposerContext()\n  const [editorState, setEditorState] = useState(editor.getEditorState().toJSON())\n\n  useEffect(() => {\n    return editor.registerUpdateListener(({ editorState }) => {\n      setEditorState(editorState.toJSON())\n    })\n  }, [editor])\n\n  return (\n    <div className=\"debug-jsx-converter\">\n      <RichText converters={defaultJSXConverters} data={editorState} />\n    </div>\n  )\n}\n"],"mappings":"AAAA;;AAAA,SAAAA,CAAA,IAAAC,EAAA;;AAEA,SAASC,yBAAyB,QAAQ;AAC1C,SAASC,SAAS,EAAEC,QAAQ,QAAQ;AAEpC;AACA,SAASC,oBAAoB,EAAEC,QAAQ,QAAQ;AAG/C,OAAO,SAAAC,eAAA;EAAA,MAAAC,CAAA,GAAAP,EAAA;EACL,OAAAQ,MAAA,IAAiBP,yBAAA;EAAA,IAAAQ,EAAA;EAAA,IAAAF,CAAA,QAAAC,MAAA;IAC8BC,EAAA,GAAAD,MAAA,CAAAE,cAAA,CAAqB,EAAAC,MAAA,CAAS;IAAAJ,CAAA,MAAAC,MAAA;IAAAD,CAAA,MAAAE,EAAA;EAAA;IAAAA,EAAA,GAAAF,CAAA;EAAA;EAA7E,OAAAK,WAAA,EAAAC,cAAA,IAAsCV,QAAA,CAASM,EAA8B;EAAA,IAAAK,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAR,CAAA,QAAAC,MAAA;IAEnEM,EAAA,GAAAA,CAAA,KACDN,MAAA,CAAAQ,sBAAA,CAAAC,EAAA;MAA+B;QAAAL,WAAA,EAAAM;MAAA,IAAAD,EAAe;MACnDJ,cAAA,CAAeD,aAAA,CAAAD,MAAA,CAAkB;IAAA,CACnC;IACCI,EAAA,IAACP,MAAA;IAAOD,CAAA,MAAAC,MAAA;IAAAD,CAAA,MAAAO,EAAA;IAAAP,CAAA,MAAAQ,EAAA;EAAA;IAAAD,EAAA,GAAAP,CAAA;IAAAQ,EAAA,GAAAR,CAAA;EAAA;EAJXL,SAAA,CAAUY,EAIV,EAAGC,EAAQ;EAAA,IAAAE,EAAA;EAAA,IAAAV,CAAA,QAAAK,WAAA;IAGTK,EAAA,GAAAE,IAAA,CAAC;MAAAC,SAAA,EAAc;MAAAC,QAAA,EACbF,IAAA,CAAAd,QAAA;QAAAiB,UAAA,EAAAlB,oBAAA;QAAAmB,IAAA,EAAkDX;MAAA,C;;;;;;;SADpDK,E","ignoreList":[]}

package/dist/features/debug/jsxConverter/server/index.js

@@ -1,9 +1,8 @@
 import { createServerFeature } from '../../../../utilities/createServerFeature.js';
 export const DebugJsxConverterFeature = createServerFeature({
-    feature: {
-        ClientFeature: '@payloadcms/richtext-lexical/client#DebugJsxConverterFeatureClient'
-    },
-    key: 'jsxConverter'
+  feature: {
+    ClientFeature: '@payloadcms/richtext-lexical/client#DebugJsxConverterFeatureClient'
+  },
+  key: 'jsxConverter'
 });
-
 //# sourceMappingURL=index.js.map

package/dist/features/debug/jsxConverter/server/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/debug/jsxConverter/server/index.ts"],"sourcesContent":["import { createServerFeature } from '../../../../utilities/createServerFeature.js'\n\nexport const DebugJsxConverterFeature = createServerFeature({\n  feature: {\n    ClientFeature: '@payloadcms/richtext-lexical/client#DebugJsxConverterFeatureClient',\n  },\n  key: 'jsxConverter',\n})\n"],"names":["createServerFeature","DebugJsxConverterFeature","feature","ClientFeature","key"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,+CAA8C;AAElF,OAAO,MAAMC,2BAA2BD,oBAAoB;IAC1DE,SAAS;QACPC,eAAe;IACjB;IACAC,KAAK;AACP,GAAE"}
+{"version":3,"file":"index.js","names":["createServerFeature","DebugJsxConverterFeature","feature","ClientFeature","key"],"sources":["../../../../../src/features/debug/jsxConverter/server/index.ts"],"sourcesContent":["import { createServerFeature } from '../../../../utilities/createServerFeature.js'\n\nexport const DebugJsxConverterFeature = createServerFeature({\n  feature: {\n    ClientFeature: '@payloadcms/richtext-lexical/client#DebugJsxConverterFeatureClient',\n  },\n  key: 'jsxConverter',\n})\n"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ;AAEpC,OAAO,MAAMC,wBAAA,GAA2BD,mBAAA,CAAoB;EAC1DE,OAAA,EAAS;IACPC,aAAA,EAAe;EACjB;EACAC,GAAA,EAAK;AACP","ignoreList":[]}