@payloadcms/richtext-lexical 3.27.0 → 3.28.0-canary.36921bd

package/dist/features/converters/html/async/converters/table.js

@@ -0,0 +1,55 @@
+export const TableHTMLConverterAsync = {
+  table: async ({
+    node,
+    nodesToHTML,
+    providedStyleTag
+  }) => {
+    const children = (await nodesToHTML({
+      nodes: node.children
+    })).join('');
+    return `<div${providedStyleTag} class="lexical-table-container">
+        <table class="lexical-table" style="border-collapse: collapse;">
+          <tbody>${children}</tbody>
+        </table>
+      </div>`;
+  },
+  tablecell: async ({
+    node,
+    nodesToHTML,
+    providedCSSString
+  }) => {
+    const children = (await nodesToHTML({
+      nodes: node.children
+    })).join('');
+    const TagName = node.headerState > 0 ? 'th' : 'td';
+    const headerStateClass = `lexical-table-cell-header-${node.headerState}`;
+    let style = 'border: 1px solid #ccc; padding: 8px;' + providedCSSString;
+    if (node.backgroundColor) {
+      style += ` background-color: ${node.backgroundColor};`;
+    }
+    const colSpanAttr = node.colSpan && node.colSpan > 1 ? ` colspan="${node.colSpan}"` : '';
+    const rowSpanAttr = node.rowSpan && node.rowSpan > 1 ? ` rowspan="${node.rowSpan}"` : '';
+    return `<${TagName}
+        class="lexical-table-cell ${headerStateClass}"
+        ${colSpanAttr}
+        ${rowSpanAttr}
+        style="${style}"
+      >
+        ${children}
+      </${TagName}>
+    `;
+  },
+  tablerow: async ({
+    node,
+    nodesToHTML,
+    providedStyleTag
+  }) => {
+    const children = (await nodesToHTML({
+      nodes: node.children
+    })).join('');
+    return `<tr${providedStyleTag} class="lexical-table-row">
+        ${children}
+      </tr>`;
+  }
+};
+//# sourceMappingURL=table.js.map

package/dist/features/converters/html/async/converters/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","names":["TableHTMLConverterAsync","table","node","nodesToHTML","providedStyleTag","children","nodes","join","tablecell","providedCSSString","TagName","headerState","headerStateClass","style","backgroundColor","colSpanAttr","colSpan","rowSpanAttr","rowSpan","tablerow"],"sources":["../../../../../../src/features/converters/html/async/converters/table.ts"],"sourcesContent":["import type {\n  SerializedTableCellNode,\n  SerializedTableNode,\n  SerializedTableRowNode,\n} from '../../../../../nodeTypes.js'\nimport type { HTMLConvertersAsync } from '../types.js'\n\nexport const TableHTMLConverterAsync: HTMLConvertersAsync<\n  SerializedTableCellNode | SerializedTableNode | SerializedTableRowNode\n> = {\n  table: async ({ node, nodesToHTML, providedStyleTag }) => {\n    const children = (\n      await nodesToHTML({\n        nodes: node.children,\n      })\n    ).join('')\n\n    return `<div${providedStyleTag} class=\"lexical-table-container\">\n        <table class=\"lexical-table\" style=\"border-collapse: collapse;\">\n          <tbody>${children}</tbody>\n        </table>\n      </div>`\n  },\n\n  tablecell: async ({ node, nodesToHTML, providedCSSString }) => {\n    const children = (\n      await nodesToHTML({\n        nodes: node.children,\n      })\n    ).join('')\n\n    const TagName = node.headerState > 0 ? 'th' : 'td'\n    const headerStateClass = `lexical-table-cell-header-${node.headerState}`\n\n    let style = 'border: 1px solid #ccc; padding: 8px;' + providedCSSString\n    if (node.backgroundColor) {\n      style += ` background-color: ${node.backgroundColor};`\n    }\n\n    const colSpanAttr = node.colSpan && node.colSpan > 1 ? ` colspan=\"${node.colSpan}\"` : ''\n    const rowSpanAttr = node.rowSpan && node.rowSpan > 1 ? ` rowspan=\"${node.rowSpan}\"` : ''\n\n    return `<${TagName}\n        class=\"lexical-table-cell ${headerStateClass}\"\n        ${colSpanAttr}\n        ${rowSpanAttr}\n        style=\"${style}\"\n      >\n        ${children}\n      </${TagName}>\n    `\n  },\n\n  tablerow: async ({ node, nodesToHTML, providedStyleTag }) => {\n    const children = (\n      await nodesToHTML({\n        nodes: node.children,\n      })\n    ).join('')\n\n    return `<tr${providedStyleTag} class=\"lexical-table-row\">\n        ${children}\n      </tr>`\n  },\n}\n"],"mappings":"AAOA,OAAO,MAAMA,uBAAA,GAET;EACFC,KAAA,EAAO,MAAAA,CAAO;IAAEC,IAAI;IAAEC,WAAW;IAAEC;EAAgB,CAAE;IACnD,MAAMC,QAAA,GAAW,CACf,MAAMF,WAAA,CAAY;MAChBG,KAAA,EAAOJ,IAAA,CAAKG;IACd,EAAC,EACDE,IAAI,CAAC;IAEP,OAAO,OAAOH,gBAAA;;mBAECC,QAAA;;aAEN;EACX;EAEAG,SAAA,EAAW,MAAAA,CAAO;IAAEN,IAAI;IAAEC,WAAW;IAAEM;EAAiB,CAAE;IACxD,MAAMJ,QAAA,GAAW,CACf,MAAMF,WAAA,CAAY;MAChBG,KAAA,EAAOJ,IAAA,CAAKG;IACd,EAAC,EACDE,IAAI,CAAC;IAEP,MAAMG,OAAA,GAAUR,IAAA,CAAKS,WAAW,GAAG,IAAI,OAAO;IAC9C,MAAMC,gBAAA,GAAmB,6BAA6BV,IAAA,CAAKS,WAAW,EAAE;IAExE,IAAIE,KAAA,GAAQ,0CAA0CJ,iBAAA;IACtD,IAAIP,IAAA,CAAKY,eAAe,EAAE;MACxBD,KAAA,IAAS,sBAAsBX,IAAA,CAAKY,eAAe,GAAG;IACxD;IAEA,MAAMC,WAAA,GAAcb,IAAA,CAAKc,OAAO,IAAId,IAAA,CAAKc,OAAO,GAAG,IAAI,aAAad,IAAA,CAAKc,OAAO,GAAG,GAAG;IACtF,MAAMC,WAAA,GAAcf,IAAA,CAAKgB,OAAO,IAAIhB,IAAA,CAAKgB,OAAO,GAAG,IAAI,aAAahB,IAAA,CAAKgB,OAAO,GAAG,GAAG;IAEtF,OAAO,IAAIR,OAAA;oCACqBE,gBAAA;UAC1BG,WAAA;UACAE,WAAA;iBACOJ,KAAA;;UAEPR,QAAA;UACAK,OAAA;KACL;EACH;EAEAS,QAAA,EAAU,MAAAA,CAAO;IAAEjB,IAAI;IAAEC,WAAW;IAAEC;EAAgB,CAAE;IACtD,MAAMC,QAAA,GAAW,CACf,MAAMF,WAAA,CAAY;MAChBG,KAAA,EAAOJ,IAAA,CAAKG;IACd,EAAC,EACDE,IAAI,CAAC;IAEP,OAAO,MAAMH,gBAAA;UACPC,QAAA;YACE;EACV;AACF","ignoreList":[]}

package/dist/features/converters/html/async/converters/text.d.ts

@@ -0,0 +1,4 @@
+import type { SerializedTextNode } from '../../../../../nodeTypes.js';
+import type { HTMLConvertersAsync } from '../types.js';
+export declare const TextHTMLConverterAsync: HTMLConvertersAsync<SerializedTextNode>;
+//# sourceMappingURL=text.d.ts.map

package/dist/features/converters/html/async/converters/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html/async/converters/text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAItD,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,kBAAkB,CA4B1E,CAAA"}

package/dist/features/converters/html/async/converters/text.js

@@ -0,0 +1,31 @@
+import { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js';
+export const TextHTMLConverterAsync = {
+  text: ({
+    node
+  }) => {
+    let text = node.text;
+    if (node.format & NodeFormat.IS_BOLD) {
+      text = `<strong>${text}</strong>`;
+    }
+    if (node.format & NodeFormat.IS_ITALIC) {
+      text = `<em>${text}</em>`;
+    }
+    if (node.format & NodeFormat.IS_STRIKETHROUGH) {
+      text = `<span style="text-decoration: line-through;">${text}</span>`;
+    }
+    if (node.format & NodeFormat.IS_UNDERLINE) {
+      text = `<span style="text-decoration: underline;">${text}</span>`;
+    }
+    if (node.format & NodeFormat.IS_CODE) {
+      text = `<code>${text}</code>`;
+    }
+    if (node.format & NodeFormat.IS_SUBSCRIPT) {
+      text = `<sub>${text}</sub>`;
+    }
+    if (node.format & NodeFormat.IS_SUPERSCRIPT) {
+      text = `<sup>${text}</sup>`;
+    }
+    return text;
+  }
+};
+//# sourceMappingURL=text.js.map

package/dist/features/converters/html/async/converters/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":["NodeFormat","TextHTMLConverterAsync","text","node","format","IS_BOLD","IS_ITALIC","IS_STRIKETHROUGH","IS_UNDERLINE","IS_CODE","IS_SUBSCRIPT","IS_SUPERSCRIPT"],"sources":["../../../../../../src/features/converters/html/async/converters/text.ts"],"sourcesContent":["import type { SerializedTextNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConvertersAsync } from '../types.js'\n\nimport { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js'\n\nexport const TextHTMLConverterAsync: HTMLConvertersAsync<SerializedTextNode> = {\n  text: ({ node }) => {\n    let text = node.text\n\n    if (node.format & NodeFormat.IS_BOLD) {\n      text = `<strong>${text}</strong>`\n    }\n    if (node.format & NodeFormat.IS_ITALIC) {\n      text = `<em>${text}</em>`\n    }\n    if (node.format & NodeFormat.IS_STRIKETHROUGH) {\n      text = `<span style=\"text-decoration: line-through;\">${text}</span>`\n    }\n    if (node.format & NodeFormat.IS_UNDERLINE) {\n      text = `<span style=\"text-decoration: underline;\">${text}</span>`\n    }\n    if (node.format & NodeFormat.IS_CODE) {\n      text = `<code>${text}</code>`\n    }\n    if (node.format & NodeFormat.IS_SUBSCRIPT) {\n      text = `<sub>${text}</sub>`\n    }\n    if (node.format & NodeFormat.IS_SUPERSCRIPT) {\n      text = `<sup>${text}</sup>`\n    }\n\n    return text\n  },\n}\n"],"mappings":"AAGA,SAASA,UAAU,QAAQ;AAE3B,OAAO,MAAMC,sBAAA,GAAkE;EAC7EC,IAAA,EAAMA,CAAC;IAAEC;EAAI,CAAE;IACb,IAAID,IAAA,GAAOC,IAAA,CAAKD,IAAI;IAEpB,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWK,OAAO,EAAE;MACpCH,IAAA,GAAO,WAAWA,IAAA,WAAe;IACnC;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWM,SAAS,EAAE;MACtCJ,IAAA,GAAO,OAAOA,IAAA,OAAW;IAC3B;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWO,gBAAgB,EAAE;MAC7CL,IAAA,GAAO,gDAAgDA,IAAA,SAAa;IACtE;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWQ,YAAY,EAAE;MACzCN,IAAA,GAAO,6CAA6CA,IAAA,SAAa;IACnE;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWS,OAAO,EAAE;MACpCP,IAAA,GAAO,SAASA,IAAA,SAAa;IAC/B;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWU,YAAY,EAAE;MACzCR,IAAA,GAAO,QAAQA,IAAA,QAAY;IAC7B;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWW,cAAc,EAAE;MAC3CT,IAAA,GAAO,QAAQA,IAAA,QAAY;IAC7B;IAEA,OAAOA,IAAA;EACT;AACF","ignoreList":[]}

package/dist/features/converters/html/async/converters/upload.d.ts

@@ -0,0 +1,4 @@
+import type { SerializedUploadNode } from '../../../../../nodeTypes.js';
+import type { HTMLConvertersAsync } from '../types.js';
+export declare const UploadHTMLConverterAsync: HTMLConvertersAsync<SerializedUploadNode>;
+//# sourceMappingURL=upload.d.ts.map

package/dist/features/converters/html/async/converters/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html/async/converters/upload.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,oBAAoB,CAgF9E,CAAA"}

package/dist/features/converters/html/async/converters/upload.js

@@ -0,0 +1,66 @@
+export const UploadHTMLConverterAsync = {
+  upload: async ({
+    node,
+    populate,
+    providedStyleTag
+  }) => {
+    const uploadNode = node;
+    let uploadDoc = undefined;
+    // If there's no valid upload data, populate return an empty string
+    if (typeof uploadNode.value !== 'object') {
+      if (!populate) {
+        return '';
+      }
+      uploadDoc = await populate({
+        id: uploadNode.value,
+        collectionSlug: uploadNode.relationTo
+      });
+    } else {
+      uploadDoc = uploadNode.value;
+    }
+    if (!uploadDoc) {
+      return '';
+    }
+    const url = uploadDoc.url;
+    // 1) If upload is NOT an image, return a link
+    if (!uploadDoc.mimeType.startsWith('image')) {
+      return `<a${providedStyleTag} href="${url}" rel="noopener noreferrer">${uploadDoc.filename}</a$>`;
+    }
+    // 2) If image has no different sizes, return a simple <img />
+    if (!uploadDoc.sizes || !Object.keys(uploadDoc.sizes).length) {
+      return `
+        <img${providedStyleTag}
+          alt="${uploadDoc.filename}"
+          height="${uploadDoc.height}"
+          src="${url}"
+          width="${uploadDoc.width}"
+        />
+      `;
+    }
+    // 3) If image has different sizes, build a <picture> element with <source> tags
+    let pictureHTML = '';
+    for (const size in uploadDoc.sizes) {
+      const imageSize = uploadDoc.sizes[size];
+      if (!imageSize || !imageSize.width || !imageSize.height || !imageSize.mimeType || !imageSize.filesize || !imageSize.filename || !imageSize.url) {
+        continue;
+      }
+      pictureHTML += `
+        <source
+          media="(max-width: ${imageSize.width}px)"
+          srcset="${imageSize.url}"
+          type="${imageSize.mimeType}"
+        />
+      `;
+    }
+    pictureHTML += `
+      <img
+        alt="${uploadDoc.filename}"
+        height="${uploadDoc.height}"
+        src="${url}"
+        width="${uploadDoc.width}"
+      />
+    `;
+    return `<picture${providedStyleTag}>${pictureHTML}</picture$>`;
+  }
+};
+//# sourceMappingURL=upload.js.map

package/dist/features/converters/html/async/converters/upload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.js","names":["UploadHTMLConverterAsync","upload","node","populate","providedStyleTag","uploadNode","uploadDoc","undefined","value","id","collectionSlug","relationTo","url","mimeType","startsWith","filename","sizes","Object","keys","length","height","width","pictureHTML","size","imageSize","filesize"],"sources":["../../../../../../src/features/converters/html/async/converters/upload.ts"],"sourcesContent":["import type { FileData, FileSizeImproved, TypeWithID } from 'payload'\n\nimport type { SerializedUploadNode } from '../../../../../nodeTypes.js'\nimport type { UploadDataImproved } from '../../../../upload/server/nodes/UploadNode.js'\nimport type { HTMLConvertersAsync } from '../types.js'\n\nexport const UploadHTMLConverterAsync: HTMLConvertersAsync<SerializedUploadNode> = {\n  upload: async ({ node, populate, providedStyleTag }) => {\n    const uploadNode = node as UploadDataImproved\n\n    let uploadDoc: (FileData & TypeWithID) | undefined = undefined\n\n    // If there's no valid upload data, populate return an empty string\n    if (typeof uploadNode.value !== 'object') {\n      if (!populate) {\n        return ''\n      }\n      uploadDoc = await populate<FileData & TypeWithID>({\n        id: uploadNode.value,\n        collectionSlug: uploadNode.relationTo,\n      })\n    } else {\n      uploadDoc = uploadNode.value as unknown as FileData & TypeWithID\n    }\n\n    if (!uploadDoc) {\n      return ''\n    }\n\n    const url = uploadDoc.url\n\n    // 1) If upload is NOT an image, return a link\n    if (!uploadDoc.mimeType.startsWith('image')) {\n      return `<a${providedStyleTag} href=\"${url}\" rel=\"noopener noreferrer\">${uploadDoc.filename}</a$>`\n    }\n\n    // 2) If image has no different sizes, return a simple <img />\n    if (!uploadDoc.sizes || !Object.keys(uploadDoc.sizes).length) {\n      return `\n        <img${providedStyleTag}\n          alt=\"${uploadDoc.filename}\"\n          height=\"${uploadDoc.height}\"\n          src=\"${url}\"\n          width=\"${uploadDoc.width}\"\n        />\n      `\n    }\n\n    // 3) If image has different sizes, build a <picture> element with <source> tags\n    let pictureHTML = ''\n\n    for (const size in uploadDoc.sizes) {\n      const imageSize = uploadDoc.sizes[size] as FileSizeImproved\n\n      if (\n        !imageSize ||\n        !imageSize.width ||\n        !imageSize.height ||\n        !imageSize.mimeType ||\n        !imageSize.filesize ||\n        !imageSize.filename ||\n        !imageSize.url\n      ) {\n        continue\n      }\n\n      pictureHTML += `\n        <source\n          media=\"(max-width: ${imageSize.width}px)\"\n          srcset=\"${imageSize.url}\"\n          type=\"${imageSize.mimeType}\"\n        />\n      `\n    }\n\n    pictureHTML += `\n      <img\n        alt=\"${uploadDoc.filename}\"\n        height=\"${uploadDoc.height}\"\n        src=\"${url}\"\n        width=\"${uploadDoc.width}\"\n      />\n    `\n\n    return `<picture${providedStyleTag}>${pictureHTML}</picture$>`\n  },\n}\n"],"mappings":"AAMA,OAAO,MAAMA,wBAAA,GAAsE;EACjFC,MAAA,EAAQ,MAAAA,CAAO;IAAEC,IAAI;IAAEC,QAAQ;IAAEC;EAAgB,CAAE;IACjD,MAAMC,UAAA,GAAaH,IAAA;IAEnB,IAAII,SAAA,GAAiDC,SAAA;IAErD;IACA,IAAI,OAAOF,UAAA,CAAWG,KAAK,KAAK,UAAU;MACxC,IAAI,CAACL,QAAA,EAAU;QACb,OAAO;MACT;MACAG,SAAA,GAAY,MAAMH,QAAA,CAAgC;QAChDM,EAAA,EAAIJ,UAAA,CAAWG,KAAK;QACpBE,cAAA,EAAgBL,UAAA,CAAWM;MAC7B;IACF,OAAO;MACLL,SAAA,GAAYD,UAAA,CAAWG,KAAK;IAC9B;IAEA,IAAI,CAACF,SAAA,EAAW;MACd,OAAO;IACT;IAEA,MAAMM,GAAA,GAAMN,SAAA,CAAUM,GAAG;IAEzB;IACA,IAAI,CAACN,SAAA,CAAUO,QAAQ,CAACC,UAAU,CAAC,UAAU;MAC3C,OAAO,KAAKV,gBAAA,UAA0BQ,GAAA,+BAAkCN,SAAA,CAAUS,QAAQ,OAAO;IACnG;IAEA;IACA,IAAI,CAACT,SAAA,CAAUU,KAAK,IAAI,CAACC,MAAA,CAAOC,IAAI,CAACZ,SAAA,CAAUU,KAAK,EAAEG,MAAM,EAAE;MAC5D,OAAO;cACCf,gBAAA;iBACGE,SAAA,CAAUS,QAAQ;oBACfT,SAAA,CAAUc,MAAM;iBACnBR,GAAA;mBACEN,SAAA,CAAUe,KAAK;;OAE3B;IACH;IAEA;IACA,IAAIC,WAAA,GAAc;IAElB,KAAK,MAAMC,IAAA,IAAQjB,SAAA,CAAUU,KAAK,EAAE;MAClC,MAAMQ,SAAA,GAAYlB,SAAA,CAAUU,KAAK,CAACO,IAAA,CAAK;MAEvC,IACE,CAACC,SAAA,IACD,CAACA,SAAA,CAAUH,KAAK,IAChB,CAACG,SAAA,CAAUJ,MAAM,IACjB,CAACI,SAAA,CAAUX,QAAQ,IACnB,CAACW,SAAA,CAAUC,QAAQ,IACnB,CAACD,SAAA,CAAUT,QAAQ,IACnB,CAACS,SAAA,CAAUZ,GAAG,EACd;QACA;MACF;MAEAU,WAAA,IAAe;;+BAEUE,SAAA,CAAUH,KAAK;oBAC1BG,SAAA,CAAUZ,GAAG;kBACfY,SAAA,CAAUX,QAAQ;;OAE7B;IACH;IAEAS,WAAA,IAAe;;eAEJhB,SAAA,CAAUS,QAAQ;kBACfT,SAAA,CAAUc,MAAM;eACnBR,GAAA;iBACEN,SAAA,CAAUe,KAAK;;KAE3B;IAED,OAAO,WAAWjB,gBAAA,IAAoBkB,WAAA,aAAwB;EAChE;AACF","ignoreList":[]}

package/dist/features/converters/html/async/defaultConverters.d.ts

@@ -0,0 +1,4 @@
+import type { DefaultNodeTypes } from '../../../../nodeTypes.js';
+import type { HTMLConvertersAsync } from './types.js';
+export declare const defaultHTMLConvertersAsync: HTMLConvertersAsync<DefaultNodeTypes>;
+//# sourceMappingURL=defaultConverters.d.ts.map

package/dist/features/converters/html/async/defaultConverters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html/async/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAcrD,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,gBAAgB,CAY5E,CAAA"}

package/dist/features/converters/html/async/defaultConverters.js

@@ -0,0 +1,25 @@
+import { BlockquoteHTMLConverterAsync } from './converters/blockquote.js';
+import { HeadingHTMLConverterAsync } from './converters/heading.js';
+import { HorizontalRuleHTMLConverterAsync } from './converters/horizontalRule.js';
+import { LinebreakHTMLConverterAsync } from './converters/linebreak.js';
+import { LinkHTMLConverterAsync } from './converters/link.js';
+import { ListHTMLConverterAsync } from './converters/list.js';
+import { ParagraphHTMLConverterAsync } from './converters/paragraph.js';
+import { TabHTMLConverterAsync } from './converters/tab.js';
+import { TableHTMLConverterAsync } from './converters/table.js';
+import { TextHTMLConverterAsync } from './converters/text.js';
+import { UploadHTMLConverterAsync } from './converters/upload.js';
+export const defaultHTMLConvertersAsync = {
+  ...ParagraphHTMLConverterAsync,
+  ...TextHTMLConverterAsync,
+  ...LinebreakHTMLConverterAsync,
+  ...BlockquoteHTMLConverterAsync,
+  ...TableHTMLConverterAsync,
+  ...HeadingHTMLConverterAsync,
+  ...HorizontalRuleHTMLConverterAsync,
+  ...ListHTMLConverterAsync,
+  ...LinkHTMLConverterAsync({}),
+  ...UploadHTMLConverterAsync,
+  ...TabHTMLConverterAsync
+};
+//# sourceMappingURL=defaultConverters.js.map

package/dist/features/converters/html/async/defaultConverters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConverters.js","names":["BlockquoteHTMLConverterAsync","HeadingHTMLConverterAsync","HorizontalRuleHTMLConverterAsync","LinebreakHTMLConverterAsync","LinkHTMLConverterAsync","ListHTMLConverterAsync","ParagraphHTMLConverterAsync","TabHTMLConverterAsync","TableHTMLConverterAsync","TextHTMLConverterAsync","UploadHTMLConverterAsync","defaultHTMLConvertersAsync"],"sources":["../../../../../src/features/converters/html/async/defaultConverters.ts"],"sourcesContent":["import type { DefaultNodeTypes } from '../../../../nodeTypes.js'\nimport type { HTMLConvertersAsync } from './types.js'\n\nimport { BlockquoteHTMLConverterAsync } from './converters/blockquote.js'\nimport { HeadingHTMLConverterAsync } from './converters/heading.js'\nimport { HorizontalRuleHTMLConverterAsync } from './converters/horizontalRule.js'\nimport { LinebreakHTMLConverterAsync } from './converters/linebreak.js'\nimport { LinkHTMLConverterAsync } from './converters/link.js'\nimport { ListHTMLConverterAsync } from './converters/list.js'\nimport { ParagraphHTMLConverterAsync } from './converters/paragraph.js'\nimport { TabHTMLConverterAsync } from './converters/tab.js'\nimport { TableHTMLConverterAsync } from './converters/table.js'\nimport { TextHTMLConverterAsync } from './converters/text.js'\nimport { UploadHTMLConverterAsync } from './converters/upload.js'\n\nexport const defaultHTMLConvertersAsync: HTMLConvertersAsync<DefaultNodeTypes> = {\n  ...ParagraphHTMLConverterAsync,\n  ...TextHTMLConverterAsync,\n  ...LinebreakHTMLConverterAsync,\n  ...BlockquoteHTMLConverterAsync,\n  ...TableHTMLConverterAsync,\n  ...HeadingHTMLConverterAsync,\n  ...HorizontalRuleHTMLConverterAsync,\n  ...ListHTMLConverterAsync,\n  ...LinkHTMLConverterAsync({}),\n  ...UploadHTMLConverterAsync,\n  ...TabHTMLConverterAsync,\n}\n"],"mappings":"AAGA,SAASA,4BAA4B,QAAQ;AAC7C,SAASC,yBAAyB,QAAQ;AAC1C,SAASC,gCAAgC,QAAQ;AACjD,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,sBAAsB,QAAQ;AACvC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,qBAAqB,QAAQ;AACtC,SAASC,uBAAuB,QAAQ;AACxC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,wBAAwB,QAAQ;AAEzC,OAAO,MAAMC,0BAAA,GAAoE;EAC/E,GAAGL,2BAA2B;EAC9B,GAAGG,sBAAsB;EACzB,GAAGN,2BAA2B;EAC9B,GAAGH,4BAA4B;EAC/B,GAAGQ,uBAAuB;EAC1B,GAAGP,yBAAyB;EAC5B,GAAGC,gCAAgC;EACnC,GAAGG,sBAAsB;EACzB,GAAGD,sBAAA,CAAuB,CAAC,EAAE;EAC7B,GAAGM,wBAAwB;EAC3B,GAAGH;AACL","ignoreList":[]}

package/dist/features/converters/html/async/field/index.d.ts

@@ -0,0 +1,33 @@
+import type { Field } from 'payload';
+import type { HTMLConvertersAsync, HTMLConvertersFunctionAsync } from '../types.js';
+type Args = {
+    converters?: HTMLConvertersAsync | HTMLConvertersFunctionAsync;
+    /**
+     * Whether the lexicalHTML field should be hidden in the admin panel
+     *
+     * @default true
+     */
+    hidden?: boolean;
+    htmlFieldName: string;
+    /**
+     * A string which matches the lexical field name you want to convert to HTML.
+     *
+     * This has to be a sibling field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.
+     **/
+    lexicalFieldName: string;
+    /**
+     * Whether the HTML should be stored in the database
+     *
+     * @default false
+     */
+    storeInDB?: boolean;
+};
+/**
+ *
+ * Field that converts a sibling lexical field to HTML
+ *
+ * @todo will be renamed to lexicalHTML in 4.0, replacing the deprecated `lexicalHTML` converter
+ */
+export declare const lexicalHTMLField: (args: Args) => Field;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/features/converters/html/async/field/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html/async/field/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAKnF,KAAK,IAAI,GAAG;IACV,UAAU,CAAC,EAAE,mBAAmB,GAAG,2BAA2B,CAAA;IAC9D;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;IACrB;;;;QAII;IACJ,gBAAgB,EAAE,MAAM,CAAA;IACxB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,KAuD9C,CAAA"}

package/dist/features/converters/html/async/field/index.js

@@ -0,0 +1,67 @@
+import { getPayloadPopulateFn } from '../../../utilities/payloadPopulateFn.js';
+import { convertLexicalToHTMLAsync } from '../index.js';
+/**
+ *
+ * Field that converts a sibling lexical field to HTML
+ *
+ * @todo will be renamed to lexicalHTML in 4.0, replacing the deprecated `lexicalHTML` converter
+ */
+export const lexicalHTMLField = args => {
+  const {
+    converters,
+    hidden = true,
+    htmlFieldName,
+    lexicalFieldName,
+    storeInDB = false
+  } = args;
+  return {
+    name: htmlFieldName,
+    type: 'code',
+    admin: {
+      editorOptions: {
+        language: 'html'
+      },
+      hidden
+    },
+    hooks: {
+      afterRead: [async ({
+        currentDepth,
+        depth,
+        draft,
+        overrideAccess,
+        req,
+        showHiddenFields,
+        siblingData
+      }) => {
+        const lexicalFieldData = siblingData[lexicalFieldName];
+        if (!lexicalFieldData) {
+          return '';
+        }
+        const htmlPopulateFn = await getPayloadPopulateFn({
+          currentDepth: currentDepth ?? 0,
+          depth: depth ?? req.payload.config.defaultDepth,
+          draft: draft ?? false,
+          overrideAccess: overrideAccess ?? false,
+          req,
+          showHiddenFields: showHiddenFields ?? false
+        });
+        return await convertLexicalToHTMLAsync({
+          converters,
+          data: lexicalFieldData,
+          populate: htmlPopulateFn
+        });
+      }],
+      beforeChange: [({
+        siblingData,
+        value
+      }) => {
+        if (storeInDB) {
+          return value;
+        }
+        delete siblingData[htmlFieldName];
+        return null;
+      }]
+    }
+  };
+};
+//# sourceMappingURL=index.js.map

package/dist/features/converters/html/async/field/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["getPayloadPopulateFn","convertLexicalToHTMLAsync","lexicalHTMLField","args","converters","hidden","htmlFieldName","lexicalFieldName","storeInDB","name","type","admin","editorOptions","language","hooks","afterRead","currentDepth","depth","draft","overrideAccess","req","showHiddenFields","siblingData","lexicalFieldData","htmlPopulateFn","payload","config","defaultDepth","data","populate","beforeChange","value"],"sources":["../../../../../../src/features/converters/html/async/field/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { Field } from 'payload'\n\nimport type { HTMLConvertersAsync, HTMLConvertersFunctionAsync } from '../types.js'\n\nimport { getPayloadPopulateFn } from '../../../utilities/payloadPopulateFn.js'\nimport { convertLexicalToHTMLAsync } from '../index.js'\n\ntype Args = {\n  converters?: HTMLConvertersAsync | HTMLConvertersFunctionAsync\n  /**\n   * Whether the lexicalHTML field should be hidden in the admin panel\n   *\n   * @default true\n   */\n  hidden?: boolean\n  htmlFieldName: string\n  /**\n   * A string which matches the lexical field name you want to convert to HTML.\n   *\n   * This has to be a sibling field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.\n   **/\n  lexicalFieldName: string\n  /**\n   * Whether the HTML should be stored in the database\n   *\n   * @default false\n   */\n  storeInDB?: boolean\n}\n\n/**\n *\n * Field that converts a sibling lexical field to HTML\n *\n * @todo will be renamed to lexicalHTML in 4.0, replacing the deprecated `lexicalHTML` converter\n */\nexport const lexicalHTMLField: (args: Args) => Field = (args) => {\n  const { converters, hidden = true, htmlFieldName, lexicalFieldName, storeInDB = false } = args\n  return {\n    name: htmlFieldName,\n    type: 'code',\n    admin: {\n      editorOptions: {\n        language: 'html',\n      },\n      hidden,\n    },\n    hooks: {\n      afterRead: [\n        async ({\n          currentDepth,\n          depth,\n          draft,\n          overrideAccess,\n          req,\n          showHiddenFields,\n          siblingData,\n        }) => {\n          const lexicalFieldData: SerializedEditorState = siblingData[lexicalFieldName]\n\n          if (!lexicalFieldData) {\n            return ''\n          }\n\n          const htmlPopulateFn = await getPayloadPopulateFn({\n            currentDepth: currentDepth ?? 0,\n            depth: depth ?? req.payload.config.defaultDepth,\n            draft: draft ?? false,\n            overrideAccess: overrideAccess ?? false,\n            req,\n            showHiddenFields: showHiddenFields ?? false,\n          })\n\n          return await convertLexicalToHTMLAsync({\n            converters,\n            data: lexicalFieldData,\n            populate: htmlPopulateFn,\n          })\n        },\n      ],\n      beforeChange: [\n        ({ siblingData, value }) => {\n          if (storeInDB) {\n            return value\n          }\n          delete siblingData[htmlFieldName]\n          return null\n        },\n      ],\n    },\n  }\n}\n"],"mappings":"AAKA,SAASA,oBAAoB,QAAQ;AACrC,SAASC,yBAAyB,QAAQ;AAyB1C;;;;;;AAMA,OAAO,MAAMC,gBAAA,GAA2CC,IAAA;EACtD,MAAM;IAAEC,UAAU;IAAEC,MAAA,GAAS,IAAI;IAAEC,aAAa;IAAEC,gBAAgB;IAAEC,SAAA,GAAY;EAAK,CAAE,GAAGL,IAAA;EAC1F,OAAO;IACLM,IAAA,EAAMH,aAAA;IACNI,IAAA,EAAM;IACNC,KAAA,EAAO;MACLC,aAAA,EAAe;QACbC,QAAA,EAAU;MACZ;MACAR;IACF;IACAS,KAAA,EAAO;MACLC,SAAA,EAAW,CACT,OAAO;QACLC,YAAY;QACZC,KAAK;QACLC,KAAK;QACLC,cAAc;QACdC,GAAG;QACHC,gBAAgB;QAChBC;MAAW,CACZ;QACC,MAAMC,gBAAA,GAA0CD,WAAW,CAACf,gBAAA,CAAiB;QAE7E,IAAI,CAACgB,gBAAA,EAAkB;UACrB,OAAO;QACT;QAEA,MAAMC,cAAA,GAAiB,MAAMxB,oBAAA,CAAqB;UAChDgB,YAAA,EAAcA,YAAA,IAAgB;UAC9BC,KAAA,EAAOA,KAAA,IAASG,GAAA,CAAIK,OAAO,CAACC,MAAM,CAACC,YAAY;UAC/CT,KAAA,EAAOA,KAAA,IAAS;UAChBC,cAAA,EAAgBA,cAAA,IAAkB;UAClCC,GAAA;UACAC,gBAAA,EAAkBA,gBAAA,IAAoB;QACxC;QAEA,OAAO,MAAMpB,yBAAA,CAA0B;UACrCG,UAAA;UACAwB,IAAA,EAAML,gBAAA;UACNM,QAAA,EAAUL;QACZ;MACF,EACD;MACDM,YAAA,EAAc,CACZ,CAAC;QAAER,WAAW;QAAES;MAAK,CAAE;QACrB,IAAIvB,SAAA,EAAW;UACb,OAAOuB,KAAA;QACT;QACA,OAAOT,WAAW,CAAChB,aAAA,CAAc;QACjC,OAAO;MACT;IAEJ;EACF;AACF","ignoreList":[]}

package/dist/features/converters/html/async/index.d.ts

@@ -0,0 +1,34 @@
+import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
+import type { HTMLConvertersAsync, HTMLConvertersFunctionAsync, HTMLPopulateFn } from './types.js';
+export type ConvertLexicalToHTMLAsyncArgs = {
+    /**
+     * Override class names for the container.
+     */
+    className?: string;
+    converters?: HTMLConvertersAsync | HTMLConvertersFunctionAsync;
+    data: SerializedEditorState;
+    /**
+     * If true, removes the container div wrapper.
+     */
+    disableContainer?: boolean;
+    /**
+     * If true, disables indentation globally. If an array, disables for specific node `type` values.
+     */
+    disableIndent?: boolean | string[];
+    /**
+     * If true, disables text alignment globally. If an array, disables for specific node `type` values.
+     */
+    disableTextAlign?: boolean | string[];
+    populate?: HTMLPopulateFn;
+};
+export declare function convertLexicalToHTMLAsync({ className, converters, data, disableContainer, disableIndent, disableTextAlign, populate, }: ConvertLexicalToHTMLAsyncArgs): Promise<string>;
+export declare function convertLexicalNodesToHTMLAsync({ converters, disableIndent, disableTextAlign, nodes, parent, populate, }: {
+    converters: HTMLConvertersAsync;
+    disableIndent?: boolean | string[];
+    disableTextAlign?: boolean | string[];
+    nodes: SerializedLexicalNode[];
+    parent: SerializedLexicalNodeWithParent;
+    populate?: HTMLPopulateFn;
+}): Promise<string[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/converters/html/async/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html/async/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAE3E,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,KAAK,EAEV,mBAAmB,EACnB,2BAA2B,EAC3B,cAAc,EACf,MAAM,YAAY,CAAA;AAMnB,MAAM,MAAM,6BAA6B,GAAG;IAC1C;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,mBAAmB,GAAG,2BAA2B,CAAA;IAC9D,IAAI,EAAE,qBAAqB,CAAA;IAC3B;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;IAClC;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;IACrC,QAAQ,CAAC,EAAE,cAAc,CAAA;CAC1B,CAAA;AAED,wBAAsB,yBAAyB,CAAC,EAC9C,SAAS,EACT,UAAU,EACV,IAAI,EACJ,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,QAAQ,GACT,EAAE,6BAA6B,GAAG,OAAO,CAAC,MAAM,CAAC,CAmCjD;AAED,wBAAsB,8BAA8B,CAAC,EACnD,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,KAAK,EACL,MAAM,EACN,QAAQ,GACT,EAAE;IACD,UAAU,EAAE,mBAAmB,CAAA;IAC/B,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;IAClC,gBAAgB,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;IACrC,KAAK,EAAE,qBAAqB,EAAE,CAAA;IAC9B,MAAM,EAAE,+BAA+B,CAAA;IACvC,QAAQ,CAAC,EAAE,cAAc,CAAA;CAC1B,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA2DpB"}

package/dist/features/converters/html/async/index.js

@@ -0,0 +1,107 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable no-console */import { hasText } from '../../../../validate/hasText.js';
+import { findConverterForNode } from '../shared/findConverterForNode.js';
+import { defaultHTMLConvertersAsync } from './defaultConverters.js';
+export async function convertLexicalToHTMLAsync({
+  className,
+  converters,
+  data,
+  disableContainer,
+  disableIndent,
+  disableTextAlign,
+  populate
+}) {
+  if (hasText(data)) {
+    let finalConverters = {};
+    if (converters) {
+      if (typeof converters === 'function') {
+        finalConverters = converters({
+          defaultConverters: defaultHTMLConvertersAsync
+        });
+      } else {
+        finalConverters = converters;
+      }
+    } else {
+      finalConverters = defaultHTMLConvertersAsync;
+    }
+    const html = (await convertLexicalNodesToHTMLAsync({
+      converters: finalConverters,
+      disableIndent,
+      disableTextAlign,
+      nodes: data?.root?.children,
+      parent: data?.root,
+      populate
+    })).join('');
+    if (disableContainer) {
+      return html;
+    } else {
+      return `<div class="${className ?? 'payload-richtext'}">${html}</div>`;
+    }
+  }
+  if (disableContainer) {
+    return '';
+  } else {
+    return `<div class="${className ?? 'payload-richtext'}"></div>`;
+  }
+}
+export async function convertLexicalNodesToHTMLAsync({
+  converters,
+  disableIndent,
+  disableTextAlign,
+  nodes,
+  parent,
+  populate
+}) {
+  const unknownConverter = converters.unknown;
+  const htmlArray = [];
+  let i = -1;
+  for (const node of nodes) {
+    i++;
+    const {
+      converterForNode,
+      providedCSSString,
+      providedStyleTag
+    } = findConverterForNode({
+      converters,
+      disableIndent,
+      disableTextAlign,
+      node,
+      unknownConverter
+    });
+    try {
+      let nodeHTML;
+      if (converterForNode) {
+        const converted = typeof converterForNode === 'function' ? await converterForNode({
+          childIndex: i,
+          converters,
+          node,
+          populate,
+          nodesToHTML: async args => {
+            return await convertLexicalNodesToHTMLAsync({
+              converters: args.converters ?? converters,
+              disableIndent: args.disableIndent ?? disableIndent,
+              disableTextAlign: args.disableTextAlign ?? disableTextAlign,
+              nodes: args.nodes,
+              parent: args.parent ?? {
+                ...node,
+                parent
+              },
+              populate
+            });
+          },
+          parent,
+          providedCSSString,
+          providedStyleTag
+        }) : converterForNode;
+        nodeHTML = converted;
+      } else {
+        nodeHTML = '<span>unknown node</span>';
+      }
+      htmlArray.push(nodeHTML);
+    } catch (error) {
+      console.error('Error converting lexical node to HTML:', error, 'node:', node);
+      htmlArray.push('');
+    }
+  }
+  return htmlArray.filter(Boolean);
+}
+//# sourceMappingURL=index.js.map

package/dist/features/converters/html/async/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["hasText","findConverterForNode","defaultHTMLConvertersAsync","convertLexicalToHTMLAsync","className","converters","data","disableContainer","disableIndent","disableTextAlign","populate","finalConverters","defaultConverters","html","convertLexicalNodesToHTMLAsync","nodes","root","children","parent","join","unknownConverter","unknown","htmlArray","i","node","converterForNode","providedCSSString","providedStyleTag","nodeHTML","converted","childIndex","nodesToHTML","args","push","error","console","filter","Boolean"],"sources":["../../../../../src/features/converters/html/async/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nimport type {\n  HTMLConverterAsync,\n  HTMLConvertersAsync,\n  HTMLConvertersFunctionAsync,\n  HTMLPopulateFn,\n} from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\nimport { defaultHTMLConvertersAsync } from './defaultConverters.js'\n\nexport type ConvertLexicalToHTMLAsyncArgs = {\n  /**\n   * Override class names for the container.\n   */\n  className?: string\n  converters?: HTMLConvertersAsync | HTMLConvertersFunctionAsync\n  data: SerializedEditorState\n  /**\n   * If true, removes the container div wrapper.\n   */\n  disableContainer?: boolean\n  /**\n   * If true, disables indentation globally. If an array, disables for specific node `type` values.\n   */\n  disableIndent?: boolean | string[]\n  /**\n   * If true, disables text alignment globally. If an array, disables for specific node `type` values.\n   */\n  disableTextAlign?: boolean | string[]\n  populate?: HTMLPopulateFn\n}\n\nexport async function convertLexicalToHTMLAsync({\n  className,\n  converters,\n  data,\n  disableContainer,\n  disableIndent,\n  disableTextAlign,\n  populate,\n}: ConvertLexicalToHTMLAsyncArgs): Promise<string> {\n  if (hasText(data)) {\n    let finalConverters: HTMLConvertersAsync = {}\n    if (converters) {\n      if (typeof converters === 'function') {\n        finalConverters = converters({ defaultConverters: defaultHTMLConvertersAsync })\n      } else {\n        finalConverters = converters\n      }\n    } else {\n      finalConverters = defaultHTMLConvertersAsync\n    }\n\n    const html = (\n      await convertLexicalNodesToHTMLAsync({\n        converters: finalConverters,\n        disableIndent,\n        disableTextAlign,\n        nodes: data?.root?.children,\n        parent: data?.root,\n        populate,\n      })\n    ).join('')\n\n    if (disableContainer) {\n      return html\n    } else {\n      return `<div class=\"${className ?? 'payload-richtext'}\">${html}</div>`\n    }\n  }\n  if (disableContainer) {\n    return ''\n  } else {\n    return `<div class=\"${className ?? 'payload-richtext'}\"></div>`\n  }\n}\n\nexport async function convertLexicalNodesToHTMLAsync({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  nodes,\n  parent,\n  populate,\n}: {\n  converters: HTMLConvertersAsync\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n  populate?: HTMLPopulateFn\n}): Promise<string[]> {\n  const unknownConverter: HTMLConverterAsync<any> = converters.unknown as HTMLConverterAsync<any>\n\n  const htmlArray: string[] = []\n\n  let i = -1\n  for (const node of nodes) {\n    i++\n    const { converterForNode, providedCSSString, providedStyleTag } = findConverterForNode({\n      converters,\n      disableIndent,\n      disableTextAlign,\n      node,\n      unknownConverter,\n    })\n\n    try {\n      let nodeHTML: string\n\n      if (converterForNode) {\n        const converted =\n          typeof converterForNode === 'function'\n            ? await converterForNode({\n                childIndex: i,\n                converters,\n                node,\n                populate,\n\n                nodesToHTML: async (args) => {\n                  return await convertLexicalNodesToHTMLAsync({\n                    converters: args.converters ?? converters,\n                    disableIndent: args.disableIndent ?? disableIndent,\n                    disableTextAlign: args.disableTextAlign ?? disableTextAlign,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                    populate,\n                  })\n                },\n                parent,\n                providedCSSString,\n                providedStyleTag,\n              })\n            : converterForNode\n        nodeHTML = converted\n      } else {\n        nodeHTML = '<span>unknown node</span>'\n      }\n\n      htmlArray.push(nodeHTML)\n    } catch (error) {\n      console.error('Error converting lexical node to HTML:', error, 'node:', node)\n      htmlArray.push('')\n    }\n  }\n\n  return htmlArray.filter(Boolean)\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/converters/html/async/types.d.ts

@@ -0,0 +1,82 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { SelectType, TypeWithID } from 'payload';
+import type { DefaultNodeTypes, SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js';
+import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
+export type HTMLPopulateArguments = {
+    collectionSlug: string;
+    id: number | string;
+    select?: SelectType;
+};
+export type HTMLPopulateFn = <TData extends object = TypeWithID>(args: HTMLPopulateArguments) => Promise<TData | undefined>;
+export type HTMLConverterAsync<T extends {
+    [key: string]: any;
+    type?: string;
+} = SerializedLexicalNode> = ((args: {
+    childIndex: number;
+    converters: HTMLConvertersAsync;
+    node: T;
+    nodesToHTML: (args: {
+        converters?: HTMLConvertersAsync;
+        disableIndent?: boolean | string[];
+        disableTextAlign?: boolean | string[];
+        nodes: SerializedLexicalNode[];
+        parent?: SerializedLexicalNodeWithParent;
+    }) => Promise<string[]>;
+    parent: SerializedLexicalNodeWithParent;
+    populate?: HTMLPopulateFn;
+    providedCSSString: string;
+    providedStyleTag: string;
+}) => Promise<string> | string) | string;
+export type HTMLConvertersAsync<T extends {
+    [key: string]: any;
+    type?: string;
+} = DefaultNodeTypes | SerializedBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}> | SerializedInlineBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}>> = {
+    [key: string]: {
+        [blockSlug: string]: HTMLConverterAsync<any>;
+    } | HTMLConverterAsync<any> | undefined;
+} & {
+    [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: HTMLConverterAsync<Extract<T, {
+        type: nodeType;
+    }>>;
+} & {
+    blocks?: {
+        [K in Extract<Extract<T, {
+            type: 'block';
+        }> extends SerializedBlockNode<infer B> ? B extends {
+            blockType: string;
+        } ? B['blockType'] : never : never, string>]?: HTMLConverterAsync<Extract<T, {
+            type: 'block';
+        }> extends SerializedBlockNode<infer B> ? SerializedBlockNode<Extract<B, {
+            blockType: K;
+        }>> : SerializedBlockNode>;
+    };
+    inlineBlocks?: {
+        [K in Extract<Extract<T, {
+            type: 'inlineBlock';
+        }> extends SerializedInlineBlockNode<infer B> ? B extends {
+            blockType: string;
+        } ? B['blockType'] : never : never, string>]?: HTMLConverterAsync<Extract<T, {
+            type: 'inlineBlock';
+        }> extends SerializedInlineBlockNode<infer B> ? SerializedInlineBlockNode<Extract<B, {
+            blockType: K;
+        }>> : SerializedInlineBlockNode>;
+    };
+};
+export type HTMLConvertersFunctionAsync<T extends {
+    [key: string]: any;
+    type?: string;
+} = DefaultNodeTypes | SerializedBlockNode<{
+    blockName?: null | string;
+}> | SerializedInlineBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}>> = (args: {
+    defaultConverters: HTMLConvertersAsync<DefaultNodeTypes>;
+}) => HTMLConvertersAsync<T>;
+//# sourceMappingURL=types.d.ts.map

package/dist/features/converters/html/async/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html/async/types.ts"],"names":[],"mappings":"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"}

package/dist/features/converters/html/async/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/html/async/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type { SelectType, TypeWithID } from 'payload'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nexport type HTMLPopulateArguments = {\n  collectionSlug: string\n  id: number | string\n  select?: SelectType\n}\n\nexport type HTMLPopulateFn = <TData extends object = TypeWithID>(\n  args: HTMLPopulateArguments,\n) => Promise<TData | undefined>\n\nexport type HTMLConverterAsync<\n  T extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> =\n  | ((args: {\n      childIndex: number\n      converters: HTMLConvertersAsync\n      node: T\n      nodesToHTML: (args: {\n        converters?: HTMLConvertersAsync\n        disableIndent?: boolean | string[]\n        disableTextAlign?: boolean | string[]\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => Promise<string[]>\n      parent: SerializedLexicalNodeWithParent\n      populate?: HTMLPopulateFn\n      providedCSSString: string\n      providedStyleTag: string\n    }) => Promise<string> | string)\n  | string\n\nexport type HTMLConvertersAsync<\n  T extends { [key: string]: any; type?: string } =\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 }>, // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: HTMLConverterAsync<any>\n      }\n    | HTMLConverterAsync<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: HTMLConverterAsync<\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    >]?: HTMLConverterAsync<\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    >]?: HTMLConverterAsync<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n}\n\nexport type HTMLConvertersFunctionAsync<\n  T extends { [key: string]: any; type?: string } =\n    | DefaultNodeTypes\n    | SerializedBlockNode<{ blockName?: null | string }>\n    | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>,\n> = (args: { defaultConverters: HTMLConvertersAsync<DefaultNodeTypes> }) => HTMLConvertersAsync<T>\n"],"mappings":"AAuFA","ignoreList":[]}