@payloadcms/richtext-lexical 3.28.0-canary.8f6d2e7 → 3.28.0-internal.2b0876e

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

@@ -0,0 +1,31 @@
+import { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js';
+export const TextHTMLConverter = {
+  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/sync/converters/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":["NodeFormat","TextHTMLConverter","text","node","format","IS_BOLD","IS_ITALIC","IS_STRIKETHROUGH","IS_UNDERLINE","IS_CODE","IS_SUBSCRIPT","IS_SUPERSCRIPT"],"sources":["../../../../../../src/features/converters/html/sync/converters/text.ts"],"sourcesContent":["import type { SerializedTextNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverters } from '../types.js'\n\nimport { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js'\n\nexport const TextHTMLConverter: HTMLConverters<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,iBAAA,GAAwD;EACnEC,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/sync/converters/upload.d.ts

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

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

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

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

@@ -0,0 +1,59 @@
+export const UploadHTMLConverter = {
+  upload: ({
+    node,
+    providedStyleTag
+  }) => {
+    const uploadNode = node;
+    let uploadDoc = undefined;
+    // If there's no valid upload data, populate return an empty string
+    if (typeof uploadNode.value !== 'object') {
+      return '';
+    } 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/sync/converters/upload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.js","names":["UploadHTMLConverter","upload","node","providedStyleTag","uploadNode","uploadDoc","undefined","value","url","mimeType","startsWith","filename","sizes","Object","keys","length","height","width","pictureHTML","size","imageSize","filesize"],"sources":["../../../../../../src/features/converters/html/sync/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 { HTMLConverters } from '../types.js'\n\nexport const UploadHTMLConverter: HTMLConverters<SerializedUploadNode> = {\n  upload: ({ node, 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      return ''\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,mBAAA,GAA4D;EACvEC,MAAA,EAAQA,CAAC;IAAEC,IAAI;IAAEC;EAAgB,CAAE;IACjC,MAAMC,UAAA,GAAaF,IAAA;IAEnB,IAAIG,SAAA,GAAiDC,SAAA;IAErD;IACA,IAAI,OAAOF,UAAA,CAAWG,KAAK,KAAK,UAAU;MACxC,OAAO;IACT,OAAO;MACLF,SAAA,GAAYD,UAAA,CAAWG,KAAK;IAC9B;IAEA,IAAI,CAACF,SAAA,EAAW;MACd,OAAO;IACT;IAEA,MAAMG,GAAA,GAAMH,SAAA,CAAUG,GAAG;IAEzB;IACA,IAAI,CAACH,SAAA,CAAUI,QAAQ,CAACC,UAAU,CAAC,UAAU;MAC3C,OAAO,KAAKP,gBAAA,UAA0BK,GAAA,+BAAkCH,SAAA,CAAUM,QAAQ,OAAO;IACnG;IAEA;IACA,IAAI,CAACN,SAAA,CAAUO,KAAK,IAAI,CAACC,MAAA,CAAOC,IAAI,CAACT,SAAA,CAAUO,KAAK,EAAEG,MAAM,EAAE;MAC5D,OAAO;cACCZ,gBAAA;iBACGE,SAAA,CAAUM,QAAQ;oBACfN,SAAA,CAAUW,MAAM;iBACnBR,GAAA;mBACEH,SAAA,CAAUY,KAAK;;OAE3B;IACH;IAEA;IACA,IAAIC,WAAA,GAAc;IAElB,KAAK,MAAMC,IAAA,IAAQd,SAAA,CAAUO,KAAK,EAAE;MAClC,MAAMQ,SAAA,GAAYf,SAAA,CAAUO,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;;eAEJb,SAAA,CAAUM,QAAQ;kBACfN,SAAA,CAAUW,MAAM;eACnBR,GAAA;iBACEH,SAAA,CAAUY,KAAK;;KAE3B;IAED,OAAO,WAAWd,gBAAA,IAAoBe,WAAA,aAAwB;EAChE;AACF","ignoreList":[]}

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

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

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

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

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

@@ -0,0 +1,25 @@
+import { BlockquoteHTMLConverter } from './converters/blockquote.js';
+import { HeadingHTMLConverter } from './converters/heading.js';
+import { HorizontalRuleHTMLConverter } from './converters/horizontalRule.js';
+import { LinebreakHTMLConverter } from './converters/linebreak.js';
+import { LinkHTMLConverter } from './converters/link.js';
+import { ListHTMLConverter } from './converters/list.js';
+import { ParagraphHTMLConverter } from './converters/paragraph.js';
+import { TabHTMLConverter } from './converters/tab.js';
+import { TableHTMLConverter } from './converters/table.js';
+import { TextHTMLConverter } from './converters/text.js';
+import { UploadHTMLConverter } from './converters/upload.js';
+export const defaultHTMLConverters = {
+  ...ParagraphHTMLConverter,
+  ...TextHTMLConverter,
+  ...LinebreakHTMLConverter,
+  ...BlockquoteHTMLConverter,
+  ...TableHTMLConverter,
+  ...HeadingHTMLConverter,
+  ...HorizontalRuleHTMLConverter,
+  ...ListHTMLConverter,
+  ...LinkHTMLConverter({}),
+  ...UploadHTMLConverter,
+  ...TabHTMLConverter
+};
+//# sourceMappingURL=defaultConverters.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConverters.js","names":["BlockquoteHTMLConverter","HeadingHTMLConverter","HorizontalRuleHTMLConverter","LinebreakHTMLConverter","LinkHTMLConverter","ListHTMLConverter","ParagraphHTMLConverter","TabHTMLConverter","TableHTMLConverter","TextHTMLConverter","UploadHTMLConverter","defaultHTMLConverters"],"sources":["../../../../../src/features/converters/html/sync/defaultConverters.ts"],"sourcesContent":["import type { DefaultNodeTypes } from '../../../../nodeTypes.js'\nimport type { HTMLConverters } from './types.js'\n\nimport { BlockquoteHTMLConverter } from './converters/blockquote.js'\nimport { HeadingHTMLConverter } from './converters/heading.js'\nimport { HorizontalRuleHTMLConverter } from './converters/horizontalRule.js'\nimport { LinebreakHTMLConverter } from './converters/linebreak.js'\nimport { LinkHTMLConverter } from './converters/link.js'\nimport { ListHTMLConverter } from './converters/list.js'\nimport { ParagraphHTMLConverter } from './converters/paragraph.js'\nimport { TabHTMLConverter } from './converters/tab.js'\nimport { TableHTMLConverter } from './converters/table.js'\nimport { TextHTMLConverter } from './converters/text.js'\nimport { UploadHTMLConverter } from './converters/upload.js'\n\nexport const defaultHTMLConverters: HTMLConverters<DefaultNodeTypes> = {\n  ...ParagraphHTMLConverter,\n  ...TextHTMLConverter,\n  ...LinebreakHTMLConverter,\n  ...BlockquoteHTMLConverter,\n  ...TableHTMLConverter,\n  ...HeadingHTMLConverter,\n  ...HorizontalRuleHTMLConverter,\n  ...ListHTMLConverter,\n  ...LinkHTMLConverter({}),\n  ...UploadHTMLConverter,\n  ...TabHTMLConverter,\n}\n"],"mappings":"AAGA,SAASA,uBAAuB,QAAQ;AACxC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,sBAAsB,QAAQ;AACvC,SAASC,iBAAiB,QAAQ;AAClC,SAASC,iBAAiB,QAAQ;AAClC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,kBAAkB,QAAQ;AACnC,SAASC,iBAAiB,QAAQ;AAClC,SAASC,mBAAmB,QAAQ;AAEpC,OAAO,MAAMC,qBAAA,GAA0D;EACrE,GAAGL,sBAAsB;EACzB,GAAGG,iBAAiB;EACpB,GAAGN,sBAAsB;EACzB,GAAGH,uBAAuB;EAC1B,GAAGQ,kBAAkB;EACrB,GAAGP,oBAAoB;EACvB,GAAGC,2BAA2B;EAC9B,GAAGG,iBAAiB;EACpB,GAAGD,iBAAA,CAAkB,CAAC,EAAE;EACxB,GAAGM,mBAAmB;EACtB,GAAGH;AACL","ignoreList":[]}

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

@@ -0,0 +1,32 @@
+import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
+import type { HTMLConverters, HTMLConvertersFunction } from './types.js';
+export type ConvertLexicalToHTMLArgs = {
+    /**
+     * Override class names for the container.
+     */
+    className?: string;
+    converters?: HTMLConverters | HTMLConvertersFunction;
+    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[];
+};
+export declare function convertLexicalToHTML({ className, converters, data, disableContainer, disableIndent, disableTextAlign, }: ConvertLexicalToHTMLArgs): string;
+export declare function convertLexicalNodesToHTML({ converters, disableIndent, disableTextAlign, nodes, parent, }: {
+    converters: HTMLConverters;
+    disableIndent?: boolean | string[];
+    disableTextAlign?: boolean | string[];
+    nodes: SerializedLexicalNode[];
+    parent: SerializedLexicalNodeWithParent;
+}): string[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html/sync/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,EAAiB,cAAc,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAMvF,MAAM,MAAM,wBAAwB,GAAG;IACrC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,cAAc,GAAG,sBAAsB,CAAA;IACpD,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;CACtC,CAAA;AAED,wBAAgB,oBAAoB,CAAC,EACnC,SAAS,EACT,UAAU,EACV,IAAI,EACJ,gBAAgB,EAChB,aAAa,EACb,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,MAAM,CAgCnC;AAED,wBAAgB,yBAAyB,CAAC,EACxC,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,KAAK,EACL,MAAM,GACP,EAAE;IACD,UAAU,EAAE,cAAc,CAAA;IAC1B,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;CACxC,GAAG,MAAM,EAAE,CAwDX"}

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

@@ -0,0 +1,102 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable no-console */import { hasText } from '../../../../validate/hasText.js';
+import { findConverterForNode } from '../shared/findConverterForNode.js';
+import { defaultHTMLConverters } from './defaultConverters.js';
+export function convertLexicalToHTML({
+  className,
+  converters,
+  data,
+  disableContainer,
+  disableIndent,
+  disableTextAlign
+}) {
+  if (hasText(data)) {
+    let finalConverters = {};
+    if (converters) {
+      if (typeof converters === 'function') {
+        finalConverters = converters({
+          defaultConverters: defaultHTMLConverters
+        });
+      } else {
+        finalConverters = converters;
+      }
+    } else {
+      finalConverters = defaultHTMLConverters;
+    }
+    const html = convertLexicalNodesToHTML({
+      converters: finalConverters,
+      disableIndent,
+      disableTextAlign,
+      nodes: data?.root?.children,
+      parent: data?.root
+    }).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 function convertLexicalNodesToHTML({
+  converters,
+  disableIndent,
+  disableTextAlign,
+  nodes,
+  parent
+}) {
+  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' ? converterForNode({
+          childIndex: i,
+          converters,
+          node,
+          nodesToHTML: args => {
+            return convertLexicalNodesToHTML({
+              converters: args.converters ?? converters,
+              disableIndent: args.disableIndent ?? disableIndent,
+              disableTextAlign: args.disableTextAlign ?? disableTextAlign,
+              nodes: args.nodes,
+              parent: args.parent ?? {
+                ...node,
+                parent
+              }
+            });
+          },
+          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/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["hasText","findConverterForNode","defaultHTMLConverters","convertLexicalToHTML","className","converters","data","disableContainer","disableIndent","disableTextAlign","finalConverters","defaultConverters","html","convertLexicalNodesToHTML","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/sync/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 { HTMLConverter, HTMLConverters, HTMLConvertersFunction } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\nimport { defaultHTMLConverters } from './defaultConverters.js'\n\nexport type ConvertLexicalToHTMLArgs = {\n  /**\n   * Override class names for the container.\n   */\n  className?: string\n  converters?: HTMLConverters | HTMLConvertersFunction\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}\n\nexport function convertLexicalToHTML({\n  className,\n  converters,\n  data,\n  disableContainer,\n  disableIndent,\n  disableTextAlign,\n}: ConvertLexicalToHTMLArgs): string {\n  if (hasText(data)) {\n    let finalConverters: HTMLConverters = {}\n    if (converters) {\n      if (typeof converters === 'function') {\n        finalConverters = converters({ defaultConverters: defaultHTMLConverters })\n      } else {\n        finalConverters = converters\n      }\n    } else {\n      finalConverters = defaultHTMLConverters\n    }\n\n    const html = convertLexicalNodesToHTML({\n      converters: finalConverters,\n      disableIndent,\n      disableTextAlign,\n      nodes: data?.root?.children,\n      parent: data?.root,\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 function convertLexicalNodesToHTML({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  nodes,\n  parent,\n}: {\n  converters: HTMLConverters\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): string[] {\n  const unknownConverter: HTMLConverter<any> = converters.unknown as HTMLConverter<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            ? converterForNode({\n                childIndex: i,\n                converters,\n                node,\n                nodesToHTML: (args) => {\n                  return convertLexicalNodesToHTML({\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                  })\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":"AAAA,wDACA,+BAMA,SAASA,OAAO,QAAQ;AACxB,SAASC,oBAAoB,QAAQ;AACrC,SAASC,qBAAqB,QAAQ;AAuBtC,OAAO,SAASC,qBAAqB;EACnCC,SAAS;EACTC,UAAU;EACVC,IAAI;EACJC,gBAAgB;EAChBC,aAAa;EACbC;AAAgB,CACS;EACzB,IAAIT,OAAA,CAAQM,IAAA,GAAO;IACjB,IAAII,eAAA,GAAkC,CAAC;IACvC,IAAIL,UAAA,EAAY;MACd,IAAI,OAAOA,UAAA,KAAe,YAAY;QACpCK,eAAA,GAAkBL,UAAA,CAAW;UAAEM,iBAAA,EAAmBT;QAAsB;MAC1E,OAAO;QACLQ,eAAA,GAAkBL,UAAA;MACpB;IACF,OAAO;MACLK,eAAA,GAAkBR,qBAAA;IACpB;IAEA,MAAMU,IAAA,GAAOC,yBAAA,CAA0B;MACrCR,UAAA,EAAYK,eAAA;MACZF,aAAA;MACAC,gBAAA;MACAK,KAAA,EAAOR,IAAA,EAAMS,IAAA,EAAMC,QAAA;MACnBC,MAAA,EAAQX,IAAA,EAAMS;IAChB,GAAGG,IAAI,CAAC;IAER,IAAIX,gBAAA,EAAkB;MACpB,OAAOK,IAAA;IACT,OAAO;MACL,OAAO,eAAeR,SAAA,IAAa,uBAAuBQ,IAAA,QAAY;IACxE;EACF;EACA,IAAIL,gBAAA,EAAkB;IACpB,OAAO;EACT,OAAO;IACL,OAAO,eAAeH,SAAA,IAAa,4BAA4B;EACjE;AACF;AAEA,OAAO,SAASS,0BAA0B;EACxCR,UAAU;EACVG,aAAa;EACbC,gBAAgB;EAChBK,KAAK;EACLG;AAAM,CAOP;EACC,MAAME,gBAAA,GAAuCd,UAAA,CAAWe,OAAO;EAE/D,MAAMC,SAAA,GAAsB,EAAE;EAE9B,IAAIC,CAAA,GAAI,CAAC;EACT,KAAK,MAAMC,IAAA,IAAQT,KAAA,EAAO;IACxBQ,CAAA;IACA,MAAM;MAAEE,gBAAgB;MAAEC,iBAAiB;MAAEC;IAAgB,CAAE,GAAGzB,oBAAA,CAAqB;MACrFI,UAAA;MACAG,aAAA;MACAC,gBAAA;MACAc,IAAA;MACAJ;IACF;IAEA,IAAI;MACF,IAAIQ,QAAA;MAEJ,IAAIH,gBAAA,EAAkB;QACpB,MAAMI,SAAA,GACJ,OAAOJ,gBAAA,KAAqB,aACxBA,gBAAA,CAAiB;UACfK,UAAA,EAAYP,CAAA;UACZjB,UAAA;UACAkB,IAAA;UACAO,WAAA,EAAcC,IAAA;YACZ,OAAOlB,yBAAA,CAA0B;cAC/BR,UAAA,EAAY0B,IAAA,CAAK1B,UAAU,IAAIA,UAAA;cAC/BG,aAAA,EAAeuB,IAAA,CAAKvB,aAAa,IAAIA,aAAA;cACrCC,gBAAA,EAAkBsB,IAAA,CAAKtB,gBAAgB,IAAIA,gBAAA;cAC3CK,KAAA,EAAOiB,IAAA,CAAKjB,KAAK;cACjBG,MAAA,EAAQc,IAAA,CAAKd,MAAM,IAAI;gBACrB,GAAGM,IAAI;gBACPN;cACF;YACF;UACF;UACAA,MAAA;UACAQ,iBAAA;UACAC;QACF,KACAF,gBAAA;QACNG,QAAA,GAAWC,SAAA;MACb,OAAO;QACLD,QAAA,GAAW;MACb;MAEAN,SAAA,CAAUW,IAAI,CAACL,QAAA;IACjB,EAAE,OAAOM,KAAA,EAAO;MACdC,OAAA,CAAQD,KAAK,CAAC,0CAA0CA,KAAA,EAAO,SAASV,IAAA;MACxEF,SAAA,CAAUW,IAAI,CAAC;IACjB;EACF;EAEA,OAAOX,SAAA,CAAUc,MAAM,CAACC,OAAA;AAC1B","ignoreList":[]}

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

@@ -0,0 +1,74 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { DefaultNodeTypes, SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js';
+import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
+export type HTMLConverter<T extends {
+    [key: string]: any;
+    type?: string;
+} = SerializedLexicalNode> = ((args: {
+    childIndex: number;
+    converters: HTMLConverters;
+    node: T;
+    nodesToHTML: (args: {
+        converters?: HTMLConverters;
+        disableIndent?: boolean | string[];
+        disableTextAlign?: boolean | string[];
+        nodes: SerializedLexicalNode[];
+        parent?: SerializedLexicalNodeWithParent;
+    }) => string[];
+    parent: SerializedLexicalNodeWithParent;
+    providedCSSString: string;
+    providedStyleTag: string;
+}) => string) | string;
+export type HTMLConverters<T extends {
+    [key: string]: any;
+    type?: string;
+} = DefaultNodeTypes | SerializedBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}> | SerializedInlineBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}>> = {
+    [key: string]: {
+        [blockSlug: string]: HTMLConverter<any>;
+    } | HTMLConverter<any> | undefined;
+} & {
+    [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: HTMLConverter<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>]?: HTMLConverter<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>]?: HTMLConverter<Extract<T, {
+            type: 'inlineBlock';
+        }> extends SerializedInlineBlockNode<infer B> ? SerializedInlineBlockNode<Extract<B, {
+            blockType: K;
+        }>> : SerializedInlineBlockNode>;
+    };
+};
+export type HTMLConvertersFunction<T extends {
+    [key: string]: any;
+    type?: string;
+} = DefaultNodeTypes | SerializedBlockNode<{
+    blockName?: null | string;
+}> | SerializedInlineBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}>> = (args: {
+    defaultConverters: HTMLConverters<DefaultNodeTypes>;
+}) => HTMLConverters<T>;
+//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/html/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 HTMLConverter<T extends { [key: string]: any; type?: string } = SerializedLexicalNode> =\n\n    | ((args: {\n        childIndex: number\n        converters: HTMLConverters\n        node: T\n        nodesToHTML: (args: {\n          converters?: HTMLConverters\n          disableIndent?: boolean | string[]\n          disableTextAlign?: boolean | string[]\n          nodes: SerializedLexicalNode[]\n          parent?: SerializedLexicalNodeWithParent\n        }) => string[]\n        parent: SerializedLexicalNodeWithParent\n        providedCSSString: string\n        providedStyleTag: string\n      }) => string)\n    | string\n\nexport type HTMLConverters<\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]: HTMLConverter<any>\n      }\n    | HTMLConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: HTMLConverter<\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    >]?: HTMLConverter<\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    >]?: HTMLConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n}\n\nexport type HTMLConvertersFunction<\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: HTMLConverters<DefaultNodeTypes> }) => HTMLConverters<T>\n"],"mappings":"AA2EA","ignoreList":[]}

package/dist/features/converters/html_deprecated/converter/converters/linebreak.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linebreak.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html_deprecated/converter/converters/linebreak.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,uBAAuB,CAKzE,CAAA"}

package/dist/features/converters/html_deprecated/converter/converters/linebreak.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linebreak.js","names":["LinebreakHTMLConverter","converter","nodeTypes"],"sources":["../../../../../../src/features/converters/html_deprecated/converter/converters/linebreak.ts"],"sourcesContent":["import type { SerializedLineBreakNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nexport const LinebreakHTMLConverter: HTMLConverter<SerializedLineBreakNode> = {\n  converter() {\n    return `<br>`\n  },\n  nodeTypes: ['linebreak'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,sBAAA,GAAiE;EAC5EC,UAAA;IACE,OAAO,MAAM;EACf;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/converters/html_deprecated/converter/converters/paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html_deprecated/converter/converters/paragraph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAIhD,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,uBAAuB,CAmCzE,CAAA"}

package/dist/features/converters/html_deprecated/converter/converters/paragraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.js","names":["convertLexicalNodesToHTML","ParagraphHTMLConverter","converter","converters","currentDepth","depth","draft","node","overrideAccess","parent","req","showHiddenFields","childrenText","lexicalNodes","children","style","format","indent","filter","Boolean","join","nodeTypes"],"sources":["../../../../../../src/features/converters/html_deprecated/converter/converters/paragraph.ts"],"sourcesContent":["import type { SerializedParagraphNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nimport { convertLexicalNodesToHTML } from '../index.js'\n\nexport const ParagraphHTMLConverter: HTMLConverter<SerializedParagraphNode> = {\n  async converter({\n    converters,\n    currentDepth,\n    depth,\n    draft,\n    node,\n    overrideAccess,\n    parent,\n    req,\n    showHiddenFields,\n  }) {\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      currentDepth,\n      depth,\n      draft,\n      lexicalNodes: node.children,\n      overrideAccess,\n      parent: {\n        ...node,\n        parent,\n      },\n      req,\n      showHiddenFields,\n    })\n    const style = [\n      node.format ? `text-align: ${node.format};` : '',\n      node.indent > 0 ? `padding-inline-start: ${node.indent * 40}px;` : '',\n    ]\n      .filter(Boolean)\n      .join(' ')\n    return `<p${style ? ` style='${style}'` : ''}>${childrenText}</p>`\n  },\n  nodeTypes: ['paragraph'],\n}\n"],"mappings":"AAGA,SAASA,yBAAyB,QAAQ;AAE1C,OAAO,MAAMC,sBAAA,GAAiE;EAC5E,MAAMC,UAAU;IACdC,UAAU;IACVC,YAAY;IACZC,KAAK;IACLC,KAAK;IACLC,IAAI;IACJC,cAAc;IACdC,MAAM;IACNC,GAAG;IACHC;EAAgB,CACjB;IACC,MAAMC,YAAA,GAAe,MAAMZ,yBAAA,CAA0B;MACnDG,UAAA;MACAC,YAAA;MACAC,KAAA;MACAC,KAAA;MACAO,YAAA,EAAcN,IAAA,CAAKO,QAAQ;MAC3BN,cAAA;MACAC,MAAA,EAAQ;QACN,GAAGF,IAAI;QACPE;MACF;MACAC,GAAA;MACAC;IACF;IACA,MAAMI,KAAA,GAAQ,CACZR,IAAA,CAAKS,MAAM,GAAG,eAAeT,IAAA,CAAKS,MAAM,GAAG,GAAG,IAC9CT,IAAA,CAAKU,MAAM,GAAG,IAAI,yBAAyBV,IAAA,CAAKU,MAAM,GAAG,OAAO,GAAG,GACpE,CACEC,MAAM,CAACC,OAAA,EACPC,IAAI,CAAC;IACR,OAAO,KAAKL,KAAA,GAAQ,WAAWA,KAAA,GAAQ,GAAG,MAAMH,YAAA,MAAkB;EACpE;EACAS,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/converters/html_deprecated/converter/converters/tab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html_deprecated/converter/converters/tab.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,iBAAiB,CAK7D,CAAA"}

package/dist/features/converters/html_deprecated/converter/converters/tab.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab.js","names":["TabHTMLConverter","converter","node","text","nodeTypes"],"sources":["../../../../../../src/features/converters/html_deprecated/converter/converters/tab.ts"],"sourcesContent":["import type { SerializedTabNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nexport const TabHTMLConverter: HTMLConverter<SerializedTabNode> = {\n  converter({ node }) {\n    return node.text\n  },\n  nodeTypes: ['tab'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,gBAAA,GAAqD;EAChEC,UAAU;IAAEC;EAAI,CAAE;IAChB,OAAOA,IAAA,CAAKC,IAAI;EAClB;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/converters/html_deprecated/converter/converters/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/html_deprecated/converter/converters/text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAIhD,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,kBAAkB,CA6B/D,CAAA"}

package/dist/features/converters/html_deprecated/converter/converters/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":["escapeHTML","NodeFormat","TextHTMLConverter","converter","node","text","format","IS_BOLD","IS_ITALIC","IS_STRIKETHROUGH","IS_UNDERLINE","IS_CODE","IS_SUBSCRIPT","IS_SUPERSCRIPT","nodeTypes"],"sources":["../../../../../../src/features/converters/html_deprecated/converter/converters/text.ts"],"sourcesContent":["import escapeHTML from 'escape-html'\n\nimport type { SerializedTextNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nimport { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js'\n\nexport const TextHTMLConverter: HTMLConverter<SerializedTextNode> = {\n  converter({ node }) {\n    let text = escapeHTML(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  nodeTypes: ['text'],\n}\n"],"mappings":"AAAA,OAAOA,UAAA,MAAgB;AAKvB,SAASC,UAAU,QAAQ;AAE3B,OAAO,MAAMC,iBAAA,GAAuD;EAClEC,UAAU;IAAEC;EAAI,CAAE;IAChB,IAAIC,IAAA,GAAOL,UAAA,CAAWI,IAAA,CAAKC,IAAI;IAE/B,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWM,OAAO,EAAE;MACpCF,IAAA,GAAO,WAAWA,IAAA,WAAe;IACnC;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWO,SAAS,EAAE;MACtCH,IAAA,GAAO,OAAOA,IAAA,OAAW;IAC3B;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWQ,gBAAgB,EAAE;MAC7CJ,IAAA,GAAO,+CAA+CA,IAAA,SAAa;IACrE;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWS,YAAY,EAAE;MACzCL,IAAA,GAAO,4CAA4CA,IAAA,SAAa;IAClE;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWU,OAAO,EAAE;MACpCN,IAAA,GAAO,SAASA,IAAA,SAAa;IAC/B;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWW,YAAY,EAAE;MACzCP,IAAA,GAAO,QAAQA,IAAA,QAAY;IAC7B;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWY,cAAc,EAAE;MAC3CR,IAAA,GAAO,QAAQA,IAAA,QAAY;IAC7B;IAEA,OAAOA,IAAA;EACT;EACAS,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/converters/{html → html_deprecated}/converter/defaultConverters.d.ts

@@ -1,3 +1,6 @@
 import type { HTMLConverter } from './types.js';
+/**
+ * @deprecated - will be removed in 4.0
+ */
 export declare const defaultHTMLConverters: HTMLConverter<any>[];
 //# sourceMappingURL=defaultConverters.d.ts.map

package/dist/features/converters/html_deprecated/converter/defaultConverters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html_deprecated/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAO/C;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,GAAG,CAAC,EAKrD,CAAA"}

package/dist/features/converters/{html → html_deprecated}/converter/defaultConverters.js

@@ -2,5 +2,8 @@ import { LinebreakHTMLConverter } from './converters/linebreak.js';
 import { ParagraphHTMLConverter } from './converters/paragraph.js';
 import { TabHTMLConverter } from './converters/tab.js';
 import { TextHTMLConverter } from './converters/text.js';
+/**
+ * @deprecated - will be removed in 4.0
+ */
 export const defaultHTMLConverters = [ParagraphHTMLConverter, TextHTMLConverter, LinebreakHTMLConverter, TabHTMLConverter];
 //# sourceMappingURL=defaultConverters.js.map

package/dist/features/converters/html_deprecated/converter/defaultConverters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConverters.js","names":["LinebreakHTMLConverter","ParagraphHTMLConverter","TabHTMLConverter","TextHTMLConverter","defaultHTMLConverters"],"sources":["../../../../../src/features/converters/html_deprecated/converter/defaultConverters.ts"],"sourcesContent":["import type { HTMLConverter } from './types.js'\n\nimport { LinebreakHTMLConverter } from './converters/linebreak.js'\nimport { ParagraphHTMLConverter } from './converters/paragraph.js'\nimport { TabHTMLConverter } from './converters/tab.js'\nimport { TextHTMLConverter } from './converters/text.js'\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport const defaultHTMLConverters: HTMLConverter<any>[] = [\n  ParagraphHTMLConverter,\n  TextHTMLConverter,\n  LinebreakHTMLConverter,\n  TabHTMLConverter,\n]\n"],"mappings":"AAEA,SAASA,sBAAsB,QAAQ;AACvC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,iBAAiB,QAAQ;AAElC;;;AAGA,OAAO,MAAMC,qBAAA,GAA8C,CACzDH,sBAAA,EACAE,iBAAA,EACAH,sBAAA,EACAE,gBAAA,CACD","ignoreList":[]}

package/dist/features/converters/{html → html_deprecated}/converter/index.d.ts

@@ -1,6 +1,9 @@
 import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
 import type { Payload, PayloadRequest } from 'payload';
 import type { HTMLConverter, SerializedLexicalNodeWithParent } from './types.js';
+/**
+ * @deprecated - will be removed in 4.0
+ */
 export type ConvertLexicalToHTMLArgs = {
     converters: HTMLConverter[];
     currentDepth?: number;
@@ -34,7 +37,13 @@ export type ConvertLexicalToHTMLArgs = {
      */
     req?: null | undefined;
 });
+/**
+ * @deprecated - will be removed in 4.0
+ */
 export declare function convertLexicalToHTML({ converters, currentDepth, data, depth, draft, overrideAccess, payload, req, showHiddenFields, }: ConvertLexicalToHTMLArgs): Promise<string>;
+/**
+ * @deprecated - will be removed in 4.0
+ */
 export declare function convertLexicalNodesToHTML({ converters, currentDepth, depth, draft, lexicalNodes, overrideAccess, parent, req, showHiddenFields, }: {
     converters: HTMLConverter[];
     currentDepth: number;

package/dist/features/converters/html_deprecated/converter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html_deprecated/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAC3E,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAItD,OAAO,KAAK,EAAE,aAAa,EAAE,+BAA+B,EAAE,MAAM,YAAY,CAAA;AAIhF;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,qBAAqB,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GAAG,CACA;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,CAAA;IACf;;;;;OAKG;IACH,GAAG,EAAE,cAAc,CAAA;CACpB,GACD;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;;OAKG;IACH,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,CAAA;CACvB,CACJ,CAAA;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,EACzC,UAAU,EACV,YAAY,EACZ,IAAI,EACJ,KAAK,EACL,KAAK,EACL,cAAc,EACd,OAAO,EACP,GAAG,EACH,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CA2B5C;AAED;;GAEG;AACH,wBAAsB,yBAAyB,CAAC,EAC9C,UAAU,EACV,YAAY,EACZ,KAAK,EACL,KAAK,EACL,YAAY,EACZ,cAAc,EACd,MAAM,EACN,GAAG,EACH,gBAAgB,GACjB,EAAE;IACD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,YAAY,EAAE,qBAAqB,EAAE,CAAA;IACrC,cAAc,EAAE,OAAO,CAAA;IACvB,MAAM,EAAE,+BAA+B,CAAA;IACvC;;OAEG;IACH,GAAG,EAAE,IAAI,GAAG,cAAc,CAAA;IAC1B,gBAAgB,EAAE,OAAO,CAAA;CAC1B,GAAG,OAAO,CAAC,MAAM,CAAC,CA8ClB"}

package/dist/features/converters/{html → html_deprecated}/converter/index.js

@@ -1,5 +1,8 @@
 import { createLocalReq } from 'payload';
 import { hasText } from '../../../../validate/hasText.js';
+/**
+ * @deprecated - will be removed in 4.0
+ */
 export async function convertLexicalToHTML({
   converters,
   currentDepth,
@@ -35,6 +38,9 @@ export async function convertLexicalToHTML({
   }
   return '';
 }
+/**
+ * @deprecated - will be removed in 4.0
+ */
 export async function convertLexicalNodesToHTML({
   converters,
   currentDepth,

package/dist/features/converters/html_deprecated/converter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createLocalReq","hasText","convertLexicalToHTML","converters","currentDepth","data","depth","draft","overrideAccess","payload","req","showHiddenFields","undefined","config","defaultDepth","convertLexicalNodesToHTML","lexicalNodes","root","children","parent","unknownConverter","find","converter","nodeTypes","includes","htmlArray","Promise","all","map","node","i","converterForNode","type","childIndex","error","console","join"],"sources":["../../../../../src/features/converters/html_deprecated/converter/index.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\nimport type { Payload, PayloadRequest } from 'payload'\n\nimport { createLocalReq } from 'payload'\n\nimport type { HTMLConverter, SerializedLexicalNodeWithParent } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport type ConvertLexicalToHTMLArgs = {\n  converters: HTMLConverter[]\n  currentDepth?: number\n  data: SerializedEditorState\n  depth?: number\n  draft?: boolean // default false\n  overrideAccess?: boolean // default false\n  showHiddenFields?: boolean // default false\n} & (\n  | {\n      /**\n       * This payload property will only be used if req is undefined.\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. If this is null or\n       * config is undefined, lexical will not create a new req object for you and local API / server-side-only\n       * functionality will be disabled.\n       */\n      req: PayloadRequest\n    }\n  | {\n      /**\n       * This payload property will only be used if req is undefined.\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. If this is null or\n       * config is undefined, lexical will not create a new req object for you and local API / server-side-only\n       * functionality will be disabled.\n       */\n      req?: null | undefined\n    }\n)\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport async function convertLexicalToHTML({\n  converters,\n  currentDepth,\n  data,\n  depth,\n  draft,\n  overrideAccess,\n  payload,\n  req,\n  showHiddenFields,\n}: ConvertLexicalToHTMLArgs): Promise<string> {\n  if (hasText(data)) {\n    if (req === undefined && payload) {\n      req = await createLocalReq({}, payload)\n    }\n\n    if (!currentDepth) {\n      currentDepth = 0\n    }\n\n    if (!depth) {\n      depth = req?.payload?.config?.defaultDepth\n    }\n\n    return await convertLexicalNodesToHTML({\n      converters,\n      currentDepth,\n      depth: depth!,\n      draft: draft === undefined ? false : draft,\n      lexicalNodes: data?.root?.children,\n      overrideAccess: overrideAccess === undefined ? false : overrideAccess,\n      parent: data?.root,\n      req: req!,\n      showHiddenFields: showHiddenFields === undefined ? false : showHiddenFields,\n    })\n  }\n  return ''\n}\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport async function convertLexicalNodesToHTML({\n  converters,\n  currentDepth,\n  depth,\n  draft,\n  lexicalNodes,\n  overrideAccess,\n  parent,\n  req,\n  showHiddenFields,\n}: {\n  converters: HTMLConverter[]\n  currentDepth: number\n  depth: number\n  draft: boolean\n  lexicalNodes: SerializedLexicalNode[]\n  overrideAccess: boolean\n  parent: SerializedLexicalNodeWithParent\n  /**\n   * When the converter is called, req CAN be passed in depending on where it's run.\n   */\n  req: null | PayloadRequest\n  showHiddenFields: boolean\n}): Promise<string> {\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n\n  const htmlArray = await Promise.all(\n    lexicalNodes.map(async (node, i) => {\n      const converterForNode = converters.find((converter) =>\n        converter.nodeTypes.includes(node.type),\n      )\n      try {\n        if (!converterForNode) {\n          if (unknownConverter) {\n            return await unknownConverter.converter({\n              childIndex: i,\n              converters,\n              currentDepth,\n              depth,\n              draft,\n              node,\n              overrideAccess,\n              parent,\n              req,\n              showHiddenFields,\n            })\n          }\n          return '<span>unknown node</span>'\n        }\n        return await converterForNode.converter({\n          childIndex: i,\n          converters,\n          currentDepth,\n          depth,\n          draft,\n          node,\n          overrideAccess,\n          parent,\n          req,\n          showHiddenFields,\n        })\n      } catch (error) {\n        console.error('Error converting lexical node to HTML:', error, 'node:', node)\n        return ''\n      }\n    }),\n  )\n\n  return htmlArray.join('') || ''\n}\n"],"mappings":"AAGA,SAASA,cAAc,QAAQ;AAI/B,SAASC,OAAO,QAAQ;AA0CxB;;;AAGA,OAAO,eAAeC,qBAAqB;EACzCC,UAAU;EACVC,YAAY;EACZC,IAAI;EACJC,KAAK;EACLC,KAAK;EACLC,cAAc;EACdC,OAAO;EACPC,GAAG;EACHC;AAAgB,CACS;EACzB,IAAIV,OAAA,CAAQI,IAAA,GAAO;IACjB,IAAIK,GAAA,KAAQE,SAAA,IAAaH,OAAA,EAAS;MAChCC,GAAA,GAAM,MAAMV,cAAA,CAAe,CAAC,GAAGS,OAAA;IACjC;IAEA,IAAI,CAACL,YAAA,EAAc;MACjBA,YAAA,GAAe;IACjB;IAEA,IAAI,CAACE,KAAA,EAAO;MACVA,KAAA,GAAQI,GAAA,EAAKD,OAAA,EAASI,MAAA,EAAQC,YAAA;IAChC;IAEA,OAAO,MAAMC,yBAAA,CAA0B;MACrCZ,UAAA;MACAC,YAAA;MACAE,KAAA,EAAOA,KAAA;MACPC,KAAA,EAAOA,KAAA,KAAUK,SAAA,GAAY,QAAQL,KAAA;MACrCS,YAAA,EAAcX,IAAA,EAAMY,IAAA,EAAMC,QAAA;MAC1BV,cAAA,EAAgBA,cAAA,KAAmBI,SAAA,GAAY,QAAQJ,cAAA;MACvDW,MAAA,EAAQd,IAAA,EAAMY,IAAA;MACdP,GAAA,EAAKA,GAAA;MACLC,gBAAA,EAAkBA,gBAAA,KAAqBC,SAAA,GAAY,QAAQD;IAC7D;EACF;EACA,OAAO;AACT;AAEA;;;AAGA,OAAO,eAAeI,0BAA0B;EAC9CZ,UAAU;EACVC,YAAY;EACZE,KAAK;EACLC,KAAK;EACLS,YAAY;EACZR,cAAc;EACdW,MAAM;EACNT,GAAG;EACHC;AAAgB,CAcjB;EACC,MAAMS,gBAAA,GAAmBjB,UAAA,CAAWkB,IAAI,CAAEC,SAAA,IAAcA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAAC;EAErF,MAAMC,SAAA,GAAY,MAAMC,OAAA,CAAQC,GAAG,CACjCX,YAAA,CAAaY,GAAG,CAAC,OAAOC,IAAA,EAAMC,CAAA;IAC5B,MAAMC,gBAAA,GAAmB5B,UAAA,CAAWkB,IAAI,CAAEC,SAAA,IACxCA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAACK,IAAA,CAAKG,IAAI;IAExC,IAAI;MACF,IAAI,CAACD,gBAAA,EAAkB;QACrB,IAAIX,gBAAA,EAAkB;UACpB,OAAO,MAAMA,gBAAA,CAAiBE,SAAS,CAAC;YACtCW,UAAA,EAAYH,CAAA;YACZ3B,UAAA;YACAC,YAAA;YACAE,KAAA;YACAC,KAAA;YACAsB,IAAA;YACArB,cAAA;YACAW,MAAA;YACAT,GAAA;YACAC;UACF;QACF;QACA,OAAO;MACT;MACA,OAAO,MAAMoB,gBAAA,CAAiBT,SAAS,CAAC;QACtCW,UAAA,EAAYH,CAAA;QACZ3B,UAAA;QACAC,YAAA;QACAE,KAAA;QACAC,KAAA;QACAsB,IAAA;QACArB,cAAA;QACAW,MAAA;QACAT,GAAA;QACAC;MACF;IACF,EAAE,OAAOuB,KAAA,EAAO;MACdC,OAAA,CAAQD,KAAK,CAAC,0CAA0CA,KAAA,EAAO,SAASL,IAAA;MACxE,OAAO;IACT;EACF;EAGF,OAAOJ,SAAA,CAAUW,IAAI,CAAC,OAAO;AAC/B","ignoreList":[]}

package/dist/features/converters/{html → html_deprecated}/converter/types.d.ts

@@ -1,5 +1,8 @@
 import type { SerializedLexicalNode } from 'lexical';
 import type { PayloadRequest } from 'payload';
+/**
+ * @deprecated - will be removed in 4.0
+ */
 export type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
     converter: (args: {
         childIndex: number;

package/dist/features/converters/html_deprecated/converter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html_deprecated/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACnF,SAAS,EAAE,CAAC,IAAI,EAAE;QAChB,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,CAAA;QAChC,YAAY,EAAE,MAAM,CAAA;QACpB,KAAK,EAAE,MAAM,CAAA;QACb,KAAK,EAAE,OAAO,CAAA;QACd,IAAI,EAAE,CAAC,CAAA;QACP,cAAc,EAAE,OAAO,CAAA;QACvB,MAAM,EAAE,+BAA+B,CAAA;QACvC;;WAEG;QACH,GAAG,EAAE,IAAI,GAAG,cAAc,CAAA;QAC1B,gBAAgB,EAAE,OAAO,CAAA;KAC1B,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,GAAG,qBAAqB,CAAA"}

package/dist/features/converters/html_deprecated/converter/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/features/converters/html_deprecated/converter/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/html_deprecated/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type { PayloadRequest } from 'payload'\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: (args: {\n    childIndex: number\n    converters: HTMLConverter<any>[]\n    currentDepth: number\n    depth: number\n    draft: boolean\n    node: T\n    overrideAccess: boolean\n    parent: SerializedLexicalNodeWithParent\n    /**\n     * When the converter is called, req CAN be passed in depending on where it's run.\n     */\n    req: null | PayloadRequest\n    showHiddenFields: boolean\n  }) => Promise<string> | string\n  nodeTypes: string[]\n}\n\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"mappings":"AAyBA","ignoreList":[]}

package/dist/features/converters/{html → html_deprecated}/field/index.d.ts

@@ -1,7 +1,7 @@
 import type { Field } from 'payload';
 import type { SanitizedServerEditorConfig } from '../../../../lexical/config/types.js';
 import type { HTMLConverter } from '../converter/types.js';
-type Props = {
+type Args = {
     /**
      * Whether the lexicalHTML field should be hidden in the admin panel
      *
@@ -19,17 +19,21 @@ type Props = {
 /**
  * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.
  *
+ * @deprecated - will be removed in 4.0
  * @param editorConfig
  */
 export declare const consolidateHTMLConverters: ({ editorConfig, }: {
     editorConfig: SanitizedServerEditorConfig;
 }) => HTMLConverter[];
+/**
+ * @deprecated - will be removed in 4.0
+ */
 export declare const lexicalHTML: (
 /**
  * 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.
+ * This has to be a sibling field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.
  **/
-lexicalFieldName: string, props: Props) => Field;
+lexicalFieldName: string, args: Args) => Field;
 export {};
 //# sourceMappingURL=index.d.ts.map