@payloadcms/richtext-lexical 3.70.0-canary.9 → 3.71.0-internal-debug.80dab4c

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

@@ -1,88 +1,89 @@
-/* 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';
-export function convertLexicalToPlaintext({
-  converters,
-  data
-}) {
-  if (hasText(data)) {
-    const plaintext = convertLexicalNodesToPlaintext({
-      converters: converters ?? {},
-      nodes: data?.root?.children,
-      parent: data?.root
-    }).join('');
-    return plaintext;
-  }
-  return '';
+/**
+   * 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 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(' | ');
+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
+                }));
+            }
         }
-      } 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,"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":[]}
+{"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"}

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

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

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

@@ -1 +1 @@
-{"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":[]}
+{"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"}

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

@@ -1,21 +1,19 @@
 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,"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":[]}
+{"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"}

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

@@ -1,42 +1,41 @@
 import { createLocalReq } from 'payload';
 import { populate } from '../../../populateGraphQL/populate.js';
-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;
+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;
 };
+
 //# sourceMappingURL=payloadPopulateFn.js.map

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

@@ -1 +1 @@
-{"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":[]}
+{"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"}

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

@@ -1,33 +1,27 @@
 import { stringify } from 'qs-esm';
-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;
+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;
 };
+
 //# sourceMappingURL=restPopulateFn.js.map

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

@@ -1 +1 @@
-{"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":[]}
+{"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"}

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

@@ -1,11 +1,13 @@
 '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,"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":[]}
+{"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"}

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

@@ -1,55 +1,35 @@
 'use client';
-
-import { c as _c } from "react/compiler-runtime";
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxDEV as _jsxDEV } from "react/jsx-dev-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 $ = _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;
+    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);
 }
+
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"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":[]}
+{"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"}

package/dist/features/debug/jsxConverter/client/plugin/style.scss

@@ -0,0 +1,12 @@
+.debug-jsx-converter {
+  // this is to match the editor component, and be able to compare aligned styles
+  padding-left: 36px;
+
+  // We revert to the browser defaults (user-agent), because we want to see
+  // the indentations look good without the need for CSS.
+  ul,
+  ol {
+    padding-left: revert;
+    margin: revert;
+  }
+}