@payloadcms/richtext-lexical 3.0.0-beta.6 → 3.0.0-beta.60

package/dist/features/blocks/nodes/BlocksNode.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js';
+import ObjectID from 'bson-objectid';
+import React from 'react';
+const BlockComponent = /*#__PURE__*/ React.lazy(()=>import('../component/index.js').then((module)=>({
+            default: module.BlockComponent
+        })));
+export class BlockNode extends DecoratorBlockNode {
+    __fields;
+    constructor({ fields, format, key }){
+        super(format, key);
+        this.__fields = fields;
+    }
+    static clone(node) {
+        return new BlockNode({
+            fields: node.__fields,
+            format: node.__format,
+            key: node.__key
+        });
+    }
+    static getType() {
+        return 'block';
+    }
+    static importDOM() {
+        return {};
+    }
+    static importJSON(serializedNode) {
+        if (serializedNode.version === 1) {
+            // Convert (version 1 had the fields wrapped in another, unnecessary data property)
+            serializedNode = {
+                ...serializedNode,
+                fields: {
+                    ...serializedNode.fields.data
+                },
+                version: 2
+            };
+        }
+        const node = $createBlockNode(serializedNode.fields);
+        node.setFormat(serializedNode.format);
+        return node;
+    }
+    static isInline() {
+        return false;
+    }
+    decorate(editor, config) {
+        // @ts-expect-error
+        return /*#__PURE__*/ _jsx(BlockComponent, {
+            formData: this.getFields(),
+            nodeKey: this.getKey()
+        });
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        const text = document.createTextNode(this.getTextContent());
+        element.append(text);
+        return {
+            element
+        };
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: 'block',
+            fields: this.getFields(),
+            version: 2
+        };
+    }
+    getFields() {
+        return this.getLatest().__fields;
+    }
+    getTextContent() {
+        return `Block Field`;
+    }
+    setFields(fields) {
+        const fieldsCopy = JSON.parse(JSON.stringify(fields));
+        const writable = this.getWritable();
+        writable.__fields = fieldsCopy;
+    }
+}
+export function $createBlockNode(fields) {
+    return new BlockNode({
+        fields: {
+            ...fields,
+            id: fields?.id || new ObjectID.default().toHexString()
+        }
+    });
+}
+export function $isBlockNode(node) {
+    return node instanceof BlockNode;
+}
+
+//# sourceMappingURL=BlocksNode.js.map

package/dist/features/blocks/nodes/BlocksNode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/blocks/nodes/BlocksNode.tsx"],"sourcesContent":["import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js'\nimport type {\n  DOMConversionMap,\n  DOMExportOutput,\n  EditorConfig,\n  ElementFormatType,\n  LexicalEditor,\n  LexicalNode,\n  NodeKey,\n  Spread,\n} from 'lexical'\n\nimport { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode.js'\nimport ObjectID from 'bson-objectid'\nimport React, { type JSX } from 'react'\n\nexport type BlockFields = {\n  /** Block form data */\n  [key: string]: any\n  blockName: string\n  blockType: string\n  id: string\n}\n\nconst BlockComponent = React.lazy(() =>\n  import('../component/index.js').then((module) => ({\n    default: module.BlockComponent,\n  })),\n)\n\nexport type SerializedBlockNode = Spread<\n  {\n    children?: never // required so that our typed editor state doesn't automatically add children\n    fields: BlockFields\n    type: 'block'\n  },\n  SerializedDecoratorBlockNode\n>\n\nexport class BlockNode extends DecoratorBlockNode {\n  __fields: BlockFields\n\n  constructor({\n    fields,\n    format,\n    key,\n  }: {\n    fields: BlockFields\n    format?: ElementFormatType\n    key?: NodeKey\n  }) {\n    super(format, key)\n    this.__fields = fields\n  }\n\n  static clone(node: BlockNode): BlockNode {\n    return new BlockNode({\n      fields: node.__fields,\n      format: node.__format,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'block'\n  }\n\n  static importDOM(): DOMConversionMap<HTMLDivElement> | null {\n    return {}\n  }\n\n  static importJSON(serializedNode: SerializedBlockNode): BlockNode {\n    if (serializedNode.version === 1) {\n      // Convert (version 1 had the fields wrapped in another, unnecessary data property)\n      serializedNode = {\n        ...serializedNode,\n        fields: {\n          ...(serializedNode as any).fields.data,\n        },\n        version: 2,\n      }\n    }\n    const node = $createBlockNode(serializedNode.fields)\n    node.setFormat(serializedNode.format)\n    return node\n  }\n\n  static isInline(): false {\n    return false\n  }\n  decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element {\n    // @ts-expect-error\n    return <BlockComponent formData={this.getFields()} nodeKey={this.getKey()} />\n  }\n\n  exportDOM(): DOMExportOutput {\n    const element = document.createElement('div')\n\n    const text = document.createTextNode(this.getTextContent())\n    element.append(text)\n    return { element }\n  }\n\n  exportJSON(): SerializedBlockNode {\n    return {\n      ...super.exportJSON(),\n      type: 'block',\n      fields: this.getFields(),\n      version: 2,\n    }\n  }\n\n  getFields(): BlockFields {\n    return this.getLatest().__fields\n  }\n\n  getTextContent(): string {\n    return `Block Field`\n  }\n\n  setFields(fields: BlockFields): void {\n    const fieldsCopy = JSON.parse(JSON.stringify(fields)) as BlockFields\n\n    const writable = this.getWritable()\n    writable.__fields = fieldsCopy\n  }\n}\n\nexport function $createBlockNode(fields: Exclude<BlockFields, 'id'>): BlockNode {\n  return new BlockNode({\n    fields: {\n      ...fields,\n      id: fields?.id || new ObjectID.default().toHexString(),\n    },\n  })\n}\n\nexport function $isBlockNode(node: BlockNode | LexicalNode | null | undefined): node is BlockNode {\n  return node instanceof BlockNode\n}\n"],"names":["DecoratorBlockNode","ObjectID","React","BlockComponent","lazy","then","module","default","BlockNode","__fields","constructor","fields","format","key","clone","node","__format","__key","getType","importDOM","importJSON","serializedNode","version","data","$createBlockNode","setFormat","isInline","decorate","editor","config","formData","getFields","nodeKey","getKey","exportDOM","element","document","createElement","text","createTextNode","getTextContent","append","exportJSON","type","getLatest","setFields","fieldsCopy","JSON","parse","stringify","writable","getWritable","id","toHexString","$isBlockNode"],"mappings":";AAYA,SAASA,kBAAkB,QAAQ,8CAA6C;AAChF,OAAOC,cAAc,gBAAe;AACpC,OAAOC,WAAyB,QAAO;AAUvC,MAAMC,+BAAiBD,MAAME,IAAI,CAAC,IAChC,MAAM,CAAC,yBAAyBC,IAAI,CAAC,CAACC,SAAY,CAAA;YAChDC,SAASD,OAAOH,cAAc;QAChC,CAAA;AAYF,OAAO,MAAMK,kBAAkBR;IAC7BS,SAAqB;IAErBC,YAAY,EACVC,MAAM,EACNC,MAAM,EACNC,GAAG,EAKJ,CAAE;QACD,KAAK,CAACD,QAAQC;QACd,IAAI,CAACJ,QAAQ,GAAGE;IAClB;IAEA,OAAOG,MAAMC,IAAe,EAAa;QACvC,OAAO,IAAIP,UAAU;YACnBG,QAAQI,KAAKN,QAAQ;YACrBG,QAAQG,KAAKC,QAAQ;YACrBH,KAAKE,KAAKE,KAAK;QACjB;IACF;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA,OAAOC,YAAqD;QAC1D,OAAO,CAAC;IACV;IAEA,OAAOC,WAAWC,cAAmC,EAAa;QAChE,IAAIA,eAAeC,OAAO,KAAK,GAAG;YAChC,mFAAmF;YACnFD,iBAAiB;gBACf,GAAGA,cAAc;gBACjBV,QAAQ;oBACN,GAAG,AAACU,eAAuBV,MAAM,CAACY,IAAI;gBACxC;gBACAD,SAAS;YACX;QACF;QACA,MAAMP,OAAOS,iBAAiBH,eAAeV,MAAM;QACnDI,KAAKU,SAAS,CAACJ,eAAeT,MAAM;QACpC,OAAOG;IACT;IAEA,OAAOW,WAAkB;QACvB,OAAO;IACT;IACAC,SAASC,MAAqB,EAAEC,MAAoB,EAAe;QACjE,mBAAmB;QACnB,qBAAO,KAAC1B;YAAe2B,UAAU,IAAI,CAACC,SAAS;YAAIC,SAAS,IAAI,CAACC,MAAM;;IACzE;IAEAC,YAA6B;QAC3B,MAAMC,UAAUC,SAASC,aAAa,CAAC;QAEvC,MAAMC,OAAOF,SAASG,cAAc,CAAC,IAAI,CAACC,cAAc;QACxDL,QAAQM,MAAM,CAACH;QACf,OAAO;YAAEH;QAAQ;IACnB;IAEAO,aAAkC;QAChC,OAAO;YACL,GAAG,KAAK,CAACA,YAAY;YACrBC,MAAM;YACNhC,QAAQ,IAAI,CAACoB,SAAS;YACtBT,SAAS;QACX;IACF;IAEAS,YAAyB;QACvB,OAAO,IAAI,CAACa,SAAS,GAAGnC,QAAQ;IAClC;IAEA+B,iBAAyB;QACvB,OAAO,CAAC,WAAW,CAAC;IACtB;IAEAK,UAAUlC,MAAmB,EAAQ;QACnC,MAAMmC,aAAaC,KAAKC,KAAK,CAACD,KAAKE,SAAS,CAACtC;QAE7C,MAAMuC,WAAW,IAAI,CAACC,WAAW;QACjCD,SAASzC,QAAQ,GAAGqC;IACtB;AACF;AAEA,OAAO,SAAStB,iBAAiBb,MAAkC;IACjE,OAAO,IAAIH,UAAU;QACnBG,QAAQ;YACN,GAAGA,MAAM;YACTyC,IAAIzC,QAAQyC,MAAM,IAAInD,SAASM,OAAO,GAAG8C,WAAW;QACtD;IACF;AACF;AAEA,OAAO,SAASC,aAAavC,IAAgD;IAC3E,OAAOA,gBAAgBP;AACzB"}

package/dist/features/blocks/plugin/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/plugin/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,kBAAkB,CAC7B,CAAA"}

package/dist/features/blocks/plugin/commands.js

@@ -0,0 +1,4 @@
+import { createCommand } from 'lexical';
+export const INSERT_BLOCK_COMMAND = createCommand('INSERT_BLOCK_COMMAND');
+
+//# sourceMappingURL=commands.js.map

package/dist/features/blocks/plugin/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/blocks/plugin/commands.ts"],"sourcesContent":["import type { LexicalCommand } from 'lexical'\n\nimport { createCommand } from 'lexical'\n\nimport type { InsertBlockPayload } from './index.js'\n\nexport const INSERT_BLOCK_COMMAND: LexicalCommand<InsertBlockPayload> =\n  createCommand('INSERT_BLOCK_COMMAND')\n"],"names":["createCommand","INSERT_BLOCK_COMMAND"],"mappings":"AAEA,SAASA,aAAa,QAAQ,UAAS;AAIvC,OAAO,MAAMC,uBACXD,cAAc,wBAAuB"}

package/dist/features/blocks/plugin/index.d.ts

@@ -0,0 +1,6 @@
+import type { PluginComponent } from '../../typesClient.js';
+import type { BlocksFeatureClientProps } from '../feature.client.js';
+import type { BlockFields } from '../nodes/BlocksNode.js';
+export type InsertBlockPayload = Exclude<BlockFields, 'id'>;
+export declare const BlocksPlugin: PluginComponent<BlocksFeatureClientProps>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/blocks/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/plugin/index.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAMzD,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;AAE3D,eAAO,MAAM,YAAY,EAAE,eAAe,CAAC,wBAAwB,CA8ClE,CAAA"}

package/dist/features/blocks/plugin/index.js

@@ -0,0 +1,42 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { $insertNodeToNearestRoot, mergeRegister } from '@lexical/utils';
+import { $getPreviousSelection, $getSelection, $isParagraphNode, $isRangeSelection, COMMAND_PRIORITY_EDITOR } from 'lexical';
+import React, { useEffect } from 'react';
+import { BlocksDrawerComponent } from '../drawer/index.js';
+import { $createBlockNode, BlockNode } from '../nodes/BlocksNode.js';
+import { INSERT_BLOCK_COMMAND } from './commands.js';
+export const BlocksPlugin = ()=>{
+    const [editor] = useLexicalComposerContext();
+    useEffect(()=>{
+        if (!editor.hasNodes([
+            BlockNode
+        ])) {
+            throw new Error('BlocksPlugin: BlocksNode not registered on editor');
+        }
+        return mergeRegister(editor.registerCommand(INSERT_BLOCK_COMMAND, (payload)=>{
+            editor.update(()=>{
+                const selection = $getSelection() || $getPreviousSelection();
+                if ($isRangeSelection(selection)) {
+                    const blockNode = $createBlockNode(payload);
+                    // Insert blocks node BEFORE potentially removing focusNode, as $insertNodeToNearestRoot errors if the focusNode doesn't exist
+                    $insertNodeToNearestRoot(blockNode);
+                    const { focus } = selection;
+                    const focusNode = focus.getNode();
+                    // First, delete currently selected node if it's an empty paragraph and if there are sufficient
+                    // paragraph nodes (more than 1) left in the parent node, so that we don't "trap" the user
+                    if ($isParagraphNode(focusNode) && focusNode.getTextContentSize() === 0 && focusNode.getParent().getChildren().filter((node)=>$isParagraphNode(node)).length > 1) {
+                        focusNode.remove();
+                    }
+                }
+            });
+            return true;
+        }, COMMAND_PRIORITY_EDITOR));
+    }, [
+        editor
+    ]);
+    return /*#__PURE__*/ _jsx(BlocksDrawerComponent, {});
+};
+
+//# sourceMappingURL=index.js.map

package/dist/features/blocks/plugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/blocks/plugin/index.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { $insertNodeToNearestRoot, mergeRegister } from '@lexical/utils'\nimport {\n  $getPreviousSelection,\n  $getSelection,\n  $isParagraphNode,\n  $isRangeSelection,\n  COMMAND_PRIORITY_EDITOR,\n} from 'lexical'\nimport React, { useEffect } from 'react'\n\nimport type { PluginComponent } from '../../typesClient.js'\nimport type { BlocksFeatureClientProps } from '../feature.client.js'\nimport type { BlockFields } from '../nodes/BlocksNode.js'\n\nimport { BlocksDrawerComponent } from '../drawer/index.js'\nimport { $createBlockNode, BlockNode } from '../nodes/BlocksNode.js'\nimport { INSERT_BLOCK_COMMAND } from './commands.js'\n\nexport type InsertBlockPayload = Exclude<BlockFields, 'id'>\n\nexport const BlocksPlugin: PluginComponent<BlocksFeatureClientProps> = () => {\n  const [editor] = useLexicalComposerContext()\n\n  useEffect(() => {\n    if (!editor.hasNodes([BlockNode])) {\n      throw new Error('BlocksPlugin: BlocksNode not registered on editor')\n    }\n\n    return mergeRegister(\n      editor.registerCommand<InsertBlockPayload>(\n        INSERT_BLOCK_COMMAND,\n        (payload: InsertBlockPayload) => {\n          editor.update(() => {\n            const selection = $getSelection() || $getPreviousSelection()\n\n            if ($isRangeSelection(selection)) {\n              const blockNode = $createBlockNode(payload)\n              // Insert blocks node BEFORE potentially removing focusNode, as $insertNodeToNearestRoot errors if the focusNode doesn't exist\n              $insertNodeToNearestRoot(blockNode)\n\n              const { focus } = selection\n              const focusNode = focus.getNode()\n\n              // First, delete currently selected node if it's an empty paragraph and if there are sufficient\n              // paragraph nodes (more than 1) left in the parent node, so that we don't \"trap\" the user\n              if (\n                $isParagraphNode(focusNode) &&\n                focusNode.getTextContentSize() === 0 &&\n                focusNode\n                  .getParent()\n                  .getChildren()\n                  .filter((node) => $isParagraphNode(node)).length > 1\n              ) {\n                focusNode.remove()\n              }\n            }\n          })\n\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n    )\n  }, [editor])\n\n  return <BlocksDrawerComponent />\n}\n"],"names":["useLexicalComposerContext","$insertNodeToNearestRoot","mergeRegister","$getPreviousSelection","$getSelection","$isParagraphNode","$isRangeSelection","COMMAND_PRIORITY_EDITOR","React","useEffect","BlocksDrawerComponent","$createBlockNode","BlockNode","INSERT_BLOCK_COMMAND","BlocksPlugin","editor","hasNodes","Error","registerCommand","payload","update","selection","blockNode","focus","focusNode","getNode","getTextContentSize","getParent","getChildren","filter","node","length","remove"],"mappings":"AAAA;;AACA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,wBAAwB,EAAEC,aAAa,QAAQ,iBAAgB;AACxE,SACEC,qBAAqB,EACrBC,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,uBAAuB,QAClB,UAAS;AAChB,OAAOC,SAASC,SAAS,QAAQ,QAAO;AAMxC,SAASC,qBAAqB,QAAQ,qBAAoB;AAC1D,SAASC,gBAAgB,EAAEC,SAAS,QAAQ,yBAAwB;AACpE,SAASC,oBAAoB,QAAQ,gBAAe;AAIpD,OAAO,MAAMC,eAA0D;IACrE,MAAM,CAACC,OAAO,GAAGf;IAEjBS,UAAU;QACR,IAAI,CAACM,OAAOC,QAAQ,CAAC;YAACJ;SAAU,GAAG;YACjC,MAAM,IAAIK,MAAM;QAClB;QAEA,OAAOf,cACLa,OAAOG,eAAe,CACpBL,sBACA,CAACM;YACCJ,OAAOK,MAAM,CAAC;gBACZ,MAAMC,YAAYjB,mBAAmBD;gBAErC,IAAIG,kBAAkBe,YAAY;oBAChC,MAAMC,YAAYX,iBAAiBQ;oBACnC,8HAA8H;oBAC9HlB,yBAAyBqB;oBAEzB,MAAM,EAAEC,KAAK,EAAE,GAAGF;oBAClB,MAAMG,YAAYD,MAAME,OAAO;oBAE/B,+FAA+F;oBAC/F,0FAA0F;oBAC1F,IACEpB,iBAAiBmB,cACjBA,UAAUE,kBAAkB,OAAO,KACnCF,UACGG,SAAS,GACTC,WAAW,GACXC,MAAM,CAAC,CAACC,OAASzB,iBAAiByB,OAAOC,MAAM,GAAG,GACrD;wBACAP,UAAUQ,MAAM;oBAClB;gBACF;YACF;YAEA,OAAO;QACT,GACAzB;IAGN,GAAG;QAACQ;KAAO;IAEX,qBAAO,KAACL;AACV,EAAC"}

package/dist/features/blocks/validate.d.ts

@@ -0,0 +1,5 @@
+import type { NodeValidation } from '../typesServer.js';
+import type { BlocksFeatureProps } from './feature.server.js';
+import type { SerializedBlockNode } from './nodes/BlocksNode.js';
+export declare const blockValidationHOC: (props: BlocksFeatureProps) => NodeValidation<SerializedBlockNode>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/features/blocks/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/features/blocks/validate.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAe,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAE7E,eAAO,MAAM,kBAAkB,UACtB,kBAAkB,KACxB,cAAc,CAAC,mBAAmB,CA2CpC,CAAA"}

package/dist/features/blocks/validate.js

@@ -0,0 +1,36 @@
+import { buildStateFromSchema } from '@payloadcms/ui/forms/buildStateFromSchema';
+export const blockValidationHOC = (props)=>{
+    return async ({ node, validation })=>{
+        const blockFieldData = node.fields ?? {};
+        const { options: { id, operation, preferences, req } } = validation;
+        // find block
+        const block = props.blocks.find((block)=>block.slug === blockFieldData.blockType);
+        // validate block
+        if (!block) {
+            return 'Block not found';
+        }
+        /**
+     * Run buildStateFromSchema as that properly validates block and block sub-fields
+     */ const result = await buildStateFromSchema({
+            id,
+            data: blockFieldData,
+            fieldSchema: block.fields,
+            operation: operation === 'create' || operation === 'update' ? operation : 'update',
+            preferences,
+            req,
+            siblingData: blockFieldData
+        });
+        let errorPaths = [];
+        for(const fieldKey in result){
+            if (result[fieldKey].errorPaths) {
+                errorPaths = errorPaths.concat(result[fieldKey].errorPaths);
+            }
+        }
+        if (errorPaths.length) {
+            return 'The following fields are invalid: ' + errorPaths.join(', ');
+        }
+        return true;
+    };
+};
+
+//# sourceMappingURL=validate.js.map

package/dist/features/blocks/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/features/blocks/validate.ts"],"sourcesContent":["import { buildStateFromSchema } from '@payloadcms/ui/forms/buildStateFromSchema'\n\nimport type { NodeValidation } from '../typesServer.js'\nimport type { BlocksFeatureProps } from './feature.server.js'\nimport type { BlockFields, SerializedBlockNode } from './nodes/BlocksNode.js'\n\nexport const blockValidationHOC = (\n  props: BlocksFeatureProps,\n): NodeValidation<SerializedBlockNode> => {\n  return async ({ node, validation }) => {\n    const blockFieldData = node.fields ?? ({} as BlockFields)\n\n    const {\n      options: { id, operation, preferences, req },\n    } = validation\n\n    // find block\n    const block = props.blocks.find((block) => block.slug === blockFieldData.blockType)\n\n    // validate block\n    if (!block) {\n      return 'Block not found'\n    }\n\n    /**\n     * Run buildStateFromSchema as that properly validates block and block sub-fields\n     */\n\n    const result = await buildStateFromSchema({\n      id,\n      data: blockFieldData,\n      fieldSchema: block.fields,\n      operation: operation === 'create' || operation === 'update' ? operation : 'update',\n      preferences,\n      req,\n      siblingData: blockFieldData,\n    })\n\n    let errorPaths = []\n    for (const fieldKey in result) {\n      if (result[fieldKey].errorPaths) {\n        errorPaths = errorPaths.concat(result[fieldKey].errorPaths)\n      }\n    }\n\n    if (errorPaths.length) {\n      return 'The following fields are invalid: ' + errorPaths.join(', ')\n    }\n\n    return true\n  }\n}\n"],"names":["buildStateFromSchema","blockValidationHOC","props","node","validation","blockFieldData","fields","options","id","operation","preferences","req","block","blocks","find","slug","blockType","result","data","fieldSchema","siblingData","errorPaths","fieldKey","concat","length","join"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,4CAA2C;AAMhF,OAAO,MAAMC,qBAAqB,CAChCC;IAEA,OAAO,OAAO,EAAEC,IAAI,EAAEC,UAAU,EAAE;QAChC,MAAMC,iBAAiBF,KAAKG,MAAM,IAAK,CAAC;QAExC,MAAM,EACJC,SAAS,EAAEC,EAAE,EAAEC,SAAS,EAAEC,WAAW,EAAEC,GAAG,EAAE,EAC7C,GAAGP;QAEJ,aAAa;QACb,MAAMQ,QAAQV,MAAMW,MAAM,CAACC,IAAI,CAAC,CAACF,QAAUA,MAAMG,IAAI,KAAKV,eAAeW,SAAS;QAElF,iBAAiB;QACjB,IAAI,CAACJ,OAAO;YACV,OAAO;QACT;QAEA;;KAEC,GAED,MAAMK,SAAS,MAAMjB,qBAAqB;YACxCQ;YACAU,MAAMb;YACNc,aAAaP,MAAMN,MAAM;YACzBG,WAAWA,cAAc,YAAYA,cAAc,WAAWA,YAAY;YAC1EC;YACAC;YACAS,aAAaf;QACf;QAEA,IAAIgB,aAAa,EAAE;QACnB,IAAK,MAAMC,YAAYL,OAAQ;YAC7B,IAAIA,MAAM,CAACK,SAAS,CAACD,UAAU,EAAE;gBAC/BA,aAAaA,WAAWE,MAAM,CAACN,MAAM,CAACK,SAAS,CAACD,UAAU;YAC5D;QACF;QAEA,IAAIA,WAAWG,MAAM,EAAE;YACrB,OAAO,uCAAuCH,WAAWI,IAAI,CAAC;QAChE;QAEA,OAAO;IACT;AACF,EAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/features/converters/html/converter/converters/linebreak.ts"],"sourcesContent":["import type { SerializedParagraphNode } from 'lexical'\n\nimport type { HTMLConverter } from '../types.js'\n\nexport const LinebreakHTMLConverter: HTMLConverter<SerializedParagraphNode> = {\n  converter() {\n    return `<br>`\n  },\n  nodeTypes: ['linebreak'],\n}\n"],"names":["LinebreakHTMLConverter","converter","nodeTypes"],"mappings":"AAIA,OAAO,MAAMA,yBAAiE;IAC5EC;QACE,OAAO,CAAC,IAAI,CAAC;IACf;IACAC,WAAW;QAAC;KAAY;AAC1B,EAAC"}

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

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

package/dist/features/converters/html/converter/converters/paragraph.js

@@ -0,0 +1,20 @@
+import { convertLexicalNodesToHTML } from '../index.js';
+export const ParagraphHTMLConverter = {
+    async converter ({ converters, node, parent, req }) {
+        const childrenText = await convertLexicalNodesToHTML({
+            converters,
+            lexicalNodes: node.children,
+            parent: {
+                ...node,
+                parent
+            },
+            req
+        });
+        return `<p>${childrenText}</p>`;
+    },
+    nodeTypes: [
+        'paragraph'
+    ]
+};
+
+//# sourceMappingURL=paragraph.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/features/converters/html/converter/converters/paragraph.ts"],"sourcesContent":["import type { SerializedParagraphNode } from 'lexical'\n\nimport type { HTMLConverter } from '../types.js'\n\nimport { convertLexicalNodesToHTML } from '../index.js'\n\nexport const ParagraphHTMLConverter: HTMLConverter<SerializedParagraphNode> = {\n  async converter({ converters, node, parent, req }) {\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: node.children,\n      parent: {\n        ...node,\n        parent,\n      },\n      req,\n    })\n    return `<p>${childrenText}</p>`\n  },\n  nodeTypes: ['paragraph'],\n}\n"],"names":["convertLexicalNodesToHTML","ParagraphHTMLConverter","converter","converters","node","parent","req","childrenText","lexicalNodes","children","nodeTypes"],"mappings":"AAIA,SAASA,yBAAyB,QAAQ,cAAa;AAEvD,OAAO,MAAMC,yBAAiE;IAC5E,MAAMC,WAAU,EAAEC,UAAU,EAAEC,IAAI,EAAEC,MAAM,EAAEC,GAAG,EAAE;QAC/C,MAAMC,eAAe,MAAMP,0BAA0B;YACnDG;YACAK,cAAcJ,KAAKK,QAAQ;YAC3BJ,QAAQ;gBACN,GAAGD,IAAI;gBACPC;YACF;YACAC;QACF;QACA,OAAO,CAAC,GAAG,EAAEC,aAAa,IAAI,CAAC;IACjC;IACAG,WAAW;QAAC;KAAY;AAC1B,EAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/features/converters/html/converter/converters/text.ts"],"sourcesContent":["import type { SerializedTextNode } from 'lexical'\n\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 = 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"],"names":["NodeFormat","TextHTMLConverter","converter","node","text","format","IS_BOLD","IS_ITALIC","IS_STRIKETHROUGH","IS_UNDERLINE","IS_CODE","IS_SUBSCRIPT","IS_SUPERSCRIPT","nodeTypes"],"mappings":"AAIA,SAASA,UAAU,QAAQ,6CAA4C;AAEvE,OAAO,MAAMC,oBAAuD;IAClEC,WAAU,EAAEC,IAAI,EAAE;QAChB,IAAIC,OAAOD,KAAKC,IAAI;QAEpB,IAAID,KAAKE,MAAM,GAAGL,WAAWM,OAAO,EAAE;YACpCF,OAAO,CAAC,QAAQ,EAAEA,KAAK,SAAS,CAAC;QACnC;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWO,SAAS,EAAE;YACtCH,OAAO,CAAC,IAAI,EAAEA,KAAK,KAAK,CAAC;QAC3B;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWQ,gBAAgB,EAAE;YAC7CJ,OAAO,CAAC,4CAA4C,EAAEA,KAAK,OAAO,CAAC;QACrE;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWS,YAAY,EAAE;YACzCL,OAAO,CAAC,yCAAyC,EAAEA,KAAK,OAAO,CAAC;QAClE;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWU,OAAO,EAAE;YACpCN,OAAO,CAAC,MAAM,EAAEA,KAAK,OAAO,CAAC;QAC/B;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWW,YAAY,EAAE;YACzCP,OAAO,CAAC,KAAK,EAAEA,KAAK,MAAM,CAAC;QAC7B;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWY,cAAc,EAAE;YAC3CR,OAAO,CAAC,KAAK,EAAEA,KAAK,MAAM,CAAC;QAC7B;QAEA,OAAOA;IACT;IACAS,WAAW;QAAC;KAAO;AACrB,EAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/features/converters/html/converter/defaultConverters.ts"],"sourcesContent":["import type { HTMLConverter } from './types.js'\n\nimport { LinebreakHTMLConverter } from './converters/linebreak.js'\nimport { ParagraphHTMLConverter } from './converters/paragraph.js'\nimport { TextHTMLConverter } from './converters/text.js'\n\nexport const defaultHTMLConverters: HTMLConverter[] = [\n  ParagraphHTMLConverter,\n  TextHTMLConverter,\n  LinebreakHTMLConverter,\n]\n"],"names":["LinebreakHTMLConverter","ParagraphHTMLConverter","TextHTMLConverter","defaultHTMLConverters"],"mappings":"AAEA,SAASA,sBAAsB,QAAQ,4BAA2B;AAClE,SAASC,sBAAsB,QAAQ,4BAA2B;AAClE,SAASC,iBAAiB,QAAQ,uBAAsB;AAExD,OAAO,MAAMC,wBAAyC;IACpDF;IACAC;IACAF;CACD,CAAA"}

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

@@ -0,0 +1,42 @@
+import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import type { Payload, PayloadRequest } from 'payload';
+import type { HTMLConverter, SerializedLexicalNodeWithParent } from './types.js';
+export type ConvertLexicalToHTMLArgs = {
+    converters: HTMLConverter[];
+    data: SerializedEditorState;
+} & ({
+    /**
+     * This payload property will only be used if req is undefined.
+     */
+    payload?: Payload;
+    /**
+     * When the converter is called, req CAN be passed in depending on where it's run.
+     * If this is undefined and config is passed through, lexical will create a new req object for you. If this is null or
+     * config is undefined, lexical will not create a new req object for you and local API / server-side-only
+     * functionality will be disabled.
+     */
+    req?: null | undefined;
+} | {
+    /**
+     * This payload property will only be used if req is undefined.
+     */
+    payload?: never;
+    /**
+     * When the converter is called, req CAN be passed in depending on where it's run.
+     * If this is undefined and config is passed through, lexical will create a new req object for you. If this is null or
+     * config is undefined, lexical will not create a new req object for you and local API / server-side-only
+     * functionality will be disabled.
+     */
+    req: PayloadRequest;
+});
+export declare function convertLexicalToHTML({ converters, data, payload, req, }: ConvertLexicalToHTMLArgs): Promise<string>;
+export declare function convertLexicalNodesToHTML({ converters, lexicalNodes, parent, req, }: {
+    converters: HTMLConverter[];
+    lexicalNodes: SerializedLexicalNode[];
+    parent: SerializedLexicalNodeWithParent;
+    /**
+     * When the converter is called, req CAN be passed in depending on where it's run.
+     */
+    req: PayloadRequest | null;
+}): Promise<string>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html/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;AAEhF,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,IAAI,EAAE,qBAAqB,CAAA;CAC5B,GAAG,CACA;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;;OAKG;IACH,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,CAAA;CACvB,GACD;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,CAAA;IACf;;;;;OAKG;IACH,GAAG,EAAE,cAAc,CAAA;CACpB,CACJ,CAAA;AAED,wBAAsB,oBAAoB,CAAC,EACzC,UAAU,EACV,IAAI,EACJ,OAAO,EACP,GAAG,GACJ,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CAc5C;AAED,wBAAsB,yBAAyB,CAAC,EAC9C,UAAU,EACV,YAAY,EACZ,MAAM,EACN,GAAG,GACJ,EAAE;IACD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,EAAE,qBAAqB,EAAE,CAAA;IACrC,MAAM,EAAE,+BAA+B,CAAA;IACvC;;OAEG;IACH,GAAG,EAAE,cAAc,GAAG,IAAI,CAAA;CAC3B,GAAG,OAAO,CAAC,MAAM,CAAC,CAoClB"}

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

@@ -0,0 +1,48 @@
+import { createLocalReq } from 'payload';
+export async function convertLexicalToHTML({ converters, data, payload, req }) {
+    if (data?.root?.children?.length) {
+        if (req === undefined && payload) {
+            req = await createLocalReq({}, payload);
+        }
+        return await convertLexicalNodesToHTML({
+            converters,
+            lexicalNodes: data?.root?.children,
+            parent: data?.root,
+            req
+        });
+    }
+    return '';
+}
+export async function convertLexicalNodesToHTML({ converters, lexicalNodes, parent, req }) {
+    const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
+    const htmlArray = await Promise.all(lexicalNodes.map(async (node, i)=>{
+        const converterForNode = converters.find((converter)=>converter.nodeTypes.includes(node.type));
+        try {
+            if (!converterForNode) {
+                if (unknownConverter) {
+                    return await unknownConverter.converter({
+                        childIndex: i,
+                        converters,
+                        node,
+                        parent,
+                        req
+                    });
+                }
+                return '<span>unknown node</span>';
+            }
+            return await converterForNode.converter({
+                childIndex: i,
+                converters,
+                node,
+                parent,
+                req
+            });
+        } catch (error) {
+            console.error('Error converting lexical node to HTML:', error, 'node:', node);
+            return '';
+        }
+    }));
+    return htmlArray.join('') || '';
+}
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/features/converters/html/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\nexport type ConvertLexicalToHTMLArgs = {\n  converters: HTMLConverter[]\n  data: SerializedEditorState\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       * 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\nexport async function convertLexicalToHTML({\n  converters,\n  data,\n  payload,\n  req,\n}: ConvertLexicalToHTMLArgs): Promise<string> {\n  if (data?.root?.children?.length) {\n    if (req === undefined && payload) {\n      req = await createLocalReq({}, payload)\n    }\n\n    return await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: data?.root?.children,\n      parent: data?.root,\n      req,\n    })\n  }\n  return ''\n}\n\nexport async function convertLexicalNodesToHTML({\n  converters,\n  lexicalNodes,\n  parent,\n  req,\n}: {\n  converters: HTMLConverter[]\n  lexicalNodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n  /**\n   * When the converter is called, req CAN be passed in depending on where it's run.\n   */\n  req: PayloadRequest | null\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              node,\n              parent,\n              req,\n            })\n          }\n          return '<span>unknown node</span>'\n        }\n        return await converterForNode.converter({\n          childIndex: i,\n          converters,\n          node,\n          parent,\n          req,\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"],"names":["createLocalReq","convertLexicalToHTML","converters","data","payload","req","root","children","length","undefined","convertLexicalNodesToHTML","lexicalNodes","parent","unknownConverter","find","converter","nodeTypes","includes","htmlArray","Promise","all","map","node","i","converterForNode","type","childIndex","error","console","join"],"mappings":"AAGA,SAASA,cAAc,QAAQ,UAAS;AAoCxC,OAAO,eAAeC,qBAAqB,EACzCC,UAAU,EACVC,IAAI,EACJC,OAAO,EACPC,GAAG,EACsB;IACzB,IAAIF,MAAMG,MAAMC,UAAUC,QAAQ;QAChC,IAAIH,QAAQI,aAAaL,SAAS;YAChCC,MAAM,MAAML,eAAe,CAAC,GAAGI;QACjC;QAEA,OAAO,MAAMM,0BAA0B;YACrCR;YACAS,cAAcR,MAAMG,MAAMC;YAC1BK,QAAQT,MAAMG;YACdD;QACF;IACF;IACA,OAAO;AACT;AAEA,OAAO,eAAeK,0BAA0B,EAC9CR,UAAU,EACVS,YAAY,EACZC,MAAM,EACNP,GAAG,EASJ;IACC,MAAMQ,mBAAmBX,WAAWY,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IAErF,MAAMC,YAAY,MAAMC,QAAQC,GAAG,CACjCT,aAAaU,GAAG,CAAC,OAAOC,MAAMC;QAC5B,MAAMC,mBAAmBtB,WAAWY,IAAI,CAAC,CAACC,YACxCA,UAAUC,SAAS,CAACC,QAAQ,CAACK,KAAKG,IAAI;QAExC,IAAI;YACF,IAAI,CAACD,kBAAkB;gBACrB,IAAIX,kBAAkB;oBACpB,OAAO,MAAMA,iBAAiBE,SAAS,CAAC;wBACtCW,YAAYH;wBACZrB;wBACAoB;wBACAV;wBACAP;oBACF;gBACF;gBACA,OAAO;YACT;YACA,OAAO,MAAMmB,iBAAiBT,SAAS,CAAC;gBACtCW,YAAYH;gBACZrB;gBACAoB;gBACAV;gBACAP;YACF;QACF,EAAE,OAAOsB,OAAO;YACdC,QAAQD,KAAK,CAAC,0CAA0CA,OAAO,SAASL;YACxE,OAAO;QACT;IACF;IAGF,OAAOJ,UAAUW,IAAI,CAAC,OAAO;AAC/B"}

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

@@ -0,0 +1,19 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { PayloadRequest } from 'payload';
+export type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
+    converter: ({ childIndex, converters, node, parent, req, }: {
+        childIndex: number;
+        converters: HTMLConverter[];
+        node: T;
+        parent: SerializedLexicalNodeWithParent;
+        /**
+         * When the converter is called, req CAN be passed in depending on where it's run.
+         */
+        req: PayloadRequest | null;
+    }) => Promise<string> | string;
+    nodeTypes: string[];
+};
+export type SerializedLexicalNodeWithParent = SerializedLexicalNode & {
+    parent?: SerializedLexicalNode;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAW,cAAc,EAAE,MAAM,SAAS,CAAA;AAEtD,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACnF,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,IAAI,EACJ,MAAM,EACN,GAAG,GACJ,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,aAAa,EAAE,CAAA;QAC3B,IAAI,EAAE,CAAC,CAAA;QACP,MAAM,EAAE,+BAA+B,CAAA;QACvC;;WAEG;QACH,GAAG,EAAE,cAAc,GAAG,IAAI,CAAA;KAC3B,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG,qBAAqB,GAAG;IACpE,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,CAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/features/converters/html/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type { Payload, PayloadRequest } from 'payload'\n\nexport type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    node,\n    parent,\n    req,\n  }: {\n    childIndex: number\n    converters: HTMLConverter[]\n    node: T\n    parent: SerializedLexicalNodeWithParent\n    /**\n     * When the converter is called, req CAN be passed in depending on where it's run.\n     */\n    req: PayloadRequest | null\n  }) => Promise<string> | string\n  nodeTypes: string[]\n}\n\nexport type SerializedLexicalNodeWithParent = SerializedLexicalNode & {\n  parent?: SerializedLexicalNode\n}\n"],"names":[],"mappings":"AAuBA,WAEC"}

package/dist/features/converters/html/feature.server.d.ts

@@ -0,0 +1,8 @@
+import type { HTMLConverter } from './converter/types.js';
+export type HTMLConverterFeatureProps = {
+    converters?: (({ defaultConverters }: {
+        defaultConverters: HTMLConverter[];
+    }) => HTMLConverter[]) | HTMLConverter[];
+};
+export declare const HTMLConverterFeature: import("../../typesServer.js").FeatureProviderProviderServer<HTMLConverterFeatureProps, HTMLConverterFeatureProps, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

package/dist/features/converters/html/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/html/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAIzD,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,CAAC,EACP,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE;QAAE,iBAAiB,EAAE,aAAa,EAAE,CAAA;KAAE,KAAK,aAAa,EAAE,CAAC,GACpF,aAAa,EAAE,CAAA;CACpB,CAAA;AAGD,eAAO,MAAM,oBAAoB,+HAG/B,CAAA"}

package/dist/features/converters/html/feature.server.js

@@ -0,0 +1,8 @@
+import { createServerFeature } from '../../../utilities/createServerFeature.js';
+// This is just used to save the props on the richText field
+export const HTMLConverterFeature = createServerFeature({
+    feature: {},
+    key: 'htmlConverter'
+});
+
+//# sourceMappingURL=feature.server.js.map

package/dist/features/converters/html/feature.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/features/converters/html/feature.server.ts"],"sourcesContent":["import type { HTMLConverter } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\n\nexport type HTMLConverterFeatureProps = {\n  converters?:\n    | (({ defaultConverters }: { defaultConverters: HTMLConverter[] }) => HTMLConverter[])\n    | HTMLConverter[]\n}\n\n// This is just used to save the props on the richText field\nexport const HTMLConverterFeature = createServerFeature<HTMLConverterFeatureProps>({\n  feature: {},\n  key: 'htmlConverter',\n})\n"],"names":["createServerFeature","HTMLConverterFeature","feature","key"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ,4CAA2C;AAQ/E,4DAA4D;AAC5D,OAAO,MAAMC,uBAAuBD,oBAA+C;IACjFE,SAAS,CAAC;IACVC,KAAK;AACP,GAAE"}

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

@@ -0,0 +1,35 @@
+import type { Field } from 'payload';
+import type { SanitizedServerEditorConfig } from '../../../../lexical/config/types.js';
+import type { HTMLConverter } from '../converter/types.js';
+type Props = {
+    /**
+     * Whether the lexicalHTML field should be hidden in the admin panel
+     *
+     * @default true
+     */
+    hidden?: boolean;
+    name: string;
+    /**
+     * Whether the HTML should be stored in the database
+     *
+     * @default false
+     */
+    storeInDB?: boolean;
+};
+/**
+ * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.
+ *
+ * @param editorConfig
+ */
+export declare const consolidateHTMLConverters: ({ editorConfig, }: {
+    editorConfig: SanitizedServerEditorConfig;
+}) => HTMLConverter[];
+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.
+ **/
+lexicalFieldName: string, props: Props) => Field;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html/field/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAqC,MAAM,SAAS,CAAA;AAEvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAA;AAEtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAM1D,KAAK,KAAK,GAAG;IACX;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,sBAEnC;IACD,YAAY,EAAE,2BAA2B,CAAA;CAC1C,KAAG,aAAa,EA+ChB,CAAA;AA0DD,eAAO,MAAM,WAAW,EAAE;AACxB;;;;IAII;AACJ,gBAAgB,EAAE,MAAM,EACxB,KAAK,EAAE,KAAK,KACT,KA6EJ,CAAA"}