@payloadcms/richtext-lexical 3.0.0-beta.13 → 3.0.0-beta.130

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

@@ -1,92 +0,0 @@
-import lexicalDecoratorBlockNodeImport from '@lexical/react/LexicalDecoratorBlockNode.js';
-const { DecoratorBlockNode } = lexicalDecoratorBlockNodeImport;
-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__*/ React.createElement(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: this.getType(),
-            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/field/features/blocks/nodes/BlocksNode.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/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 lexicalDecoratorBlockNodeImport from '@lexical/react/LexicalDecoratorBlockNode.js'\nconst { DecoratorBlockNode } = lexicalDecoratorBlockNodeImport\nimport ObjectID from 'bson-objectid'\nimport React 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    fields: BlockFields\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: this.getType(),\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":["lexicalDecoratorBlockNodeImport","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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAYA,OAAOA,qCAAqC,8CAA6C;AACzF,MAAM,EAAEC,kBAAkB,EAAE,GAAGD;AAC/B,OAAOE,cAAc,gBAAe;AACpC,OAAOC,WAAW,QAAO;AAUzB,MAAMC,+BAAiBD,MAAME,IAAI,CAAC,IAChC,MAAM,CAAC,yBAAyBC,IAAI,CAAC,CAACC,SAAY,CAAA;YAChDC,SAASD,OAAOH,cAAc;QAChC,CAAA;AAUF,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,oBAAC1B;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,IAAI,CAACzB,OAAO;YAClBP,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/field/features/blocks/plugin/commands.d.ts

@@ -1,4 +0,0 @@
-import type { LexicalCommand } from 'lexical';
-import type { InsertBlockPayload } from './index.js';
-export declare const INSERT_BLOCK_COMMAND: LexicalCommand<InsertBlockPayload>;
-//# sourceMappingURL=commands.d.ts.map

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/blocks/plugin/commands.ts"],"sourcesContent":["import type { LexicalCommand } from 'lexical'\n\nimport lexicalImport from 'lexical'\nconst { createCommand } = lexicalImport\n\nimport type { InsertBlockPayload } from './index.js'\n\nexport const INSERT_BLOCK_COMMAND: LexicalCommand<InsertBlockPayload> =\n  createCommand('INSERT_BLOCK_COMMAND')\n"],"names":["lexicalImport","createCommand","INSERT_BLOCK_COMMAND"],"rangeMappings":";;","mappings":"AAEA,OAAOA,mBAAmB,UAAS;AACnC,MAAM,EAAEC,aAAa,EAAE,GAAGD;AAI1B,OAAO,MAAME,uBACXD,cAAc,wBAAuB"}

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

@@ -1,5 +0,0 @@
-import React from 'react';
-import type { BlockFields } from '../nodes/BlocksNode.js';
-export type InsertBlockPayload = Exclude<BlockFields, 'id'>;
-export declare function BlocksPlugin(): React.ReactNode;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/blocks/plugin/index.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAoB,MAAM,OAAO,CAAA;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAMzD,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;AAE3D,wBAAgB,YAAY,IAAI,KAAK,CAAC,SAAS,CA8C9C"}

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

@@ -1,43 +0,0 @@
-'use client';
-import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
-const { useLexicalComposerContext } = lexicalComposerContextImport;
-import lexicalUtilsImport from '@lexical/utils';
-const { $insertNodeToNearestRoot, mergeRegister } = lexicalUtilsImport;
-import lexicalImport from 'lexical';
-const { $getPreviousSelection, $getSelection, $isParagraphNode, $isRangeSelection, COMMAND_PRIORITY_EDITOR } = lexicalImport;
-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 function 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 blockNode = $createBlockNode(payload);
-                const selection = $getSelection() || $getPreviousSelection();
-                if ($isRangeSelection(selection)) {
-                    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();
-                    }
-                    $insertNodeToNearestRoot(blockNode);
-                }
-            });
-            return true;
-        }, COMMAND_PRIORITY_EDITOR));
-    }, [
-        editor
-    ]);
-    return /*#__PURE__*/ React.createElement(BlocksDrawerComponent, null);
-}
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/blocks/plugin/index.tsx"],"sourcesContent":["'use client'\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\nimport lexicalUtilsImport from '@lexical/utils'\nconst { $insertNodeToNearestRoot, mergeRegister } = lexicalUtilsImport\nimport lexicalImport from 'lexical'\nconst {\n  $getPreviousSelection,\n  $getSelection,\n  $isParagraphNode,\n  $isRangeSelection,\n  COMMAND_PRIORITY_EDITOR,\n} = lexicalImport\n\nimport React, { useEffect } from 'react'\n\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 function BlocksPlugin(): React.ReactNode {\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 blockNode = $createBlockNode(payload)\n\n            const selection = $getSelection() || $getPreviousSelection()\n\n            if ($isRangeSelection(selection)) {\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              $insertNodeToNearestRoot(blockNode)\n            }\n          })\n\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n    )\n  }, [editor])\n\n  return <BlocksDrawerComponent />\n}\n"],"names":["lexicalComposerContextImport","useLexicalComposerContext","lexicalUtilsImport","$insertNodeToNearestRoot","mergeRegister","lexicalImport","$getPreviousSelection","$getSelection","$isParagraphNode","$isRangeSelection","COMMAND_PRIORITY_EDITOR","React","useEffect","BlocksDrawerComponent","$createBlockNode","BlockNode","INSERT_BLOCK_COMMAND","BlocksPlugin","editor","hasNodes","Error","registerCommand","payload","update","blockNode","selection","focus","focusNode","getNode","getTextContentSize","getParent","getChildren","filter","node","length","remove"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AACA,OAAOA,kCAAkC,2CAA0C;AACnF,MAAM,EAAEC,yBAAyB,EAAE,GAAGD;AACtC,OAAOE,wBAAwB,iBAAgB;AAC/C,MAAM,EAAEC,wBAAwB,EAAEC,aAAa,EAAE,GAAGF;AACpD,OAAOG,mBAAmB,UAAS;AACnC,MAAM,EACJC,qBAAqB,EACrBC,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,uBAAuB,EACxB,GAAGL;AAEJ,OAAOM,SAASC,SAAS,QAAQ,QAAO;AAIxC,SAASC,qBAAqB,QAAQ,qBAAoB;AAC1D,SAASC,gBAAgB,EAAEC,SAAS,QAAQ,yBAAwB;AACpE,SAASC,oBAAoB,QAAQ,gBAAe;AAIpD,OAAO,SAASC;IACd,MAAM,CAACC,OAAO,GAAGjB;IAEjBW,UAAU;QACR,IAAI,CAACM,OAAOC,QAAQ,CAAC;YAACJ;SAAU,GAAG;YACjC,MAAM,IAAIK,MAAM;QAClB;QAEA,OAAOhB,cACLc,OAAOG,eAAe,CACpBL,sBACA,CAACM;YACCJ,OAAOK,MAAM,CAAC;gBACZ,MAAMC,YAAYV,iBAAiBQ;gBAEnC,MAAMG,YAAYlB,mBAAmBD;gBAErC,IAAIG,kBAAkBgB,YAAY;oBAChC,MAAM,EAAEC,KAAK,EAAE,GAAGD;oBAClB,MAAME,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;oBAEAhC,yBAAyBqB;gBAC3B;YACF;YAEA,OAAO;QACT,GACAd;IAGN,GAAG;QAACQ;KAAO;IAEX,qBAAO,oBAACL;AACV"}

package/dist/field/features/blocks/populationPromise.d.ts

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

package/dist/field/features/blocks/populationPromise.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/blocks/populationPromise.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAIhE,eAAO,MAAM,yBAAyB,UAC7B,kBAAkB,KACxB,kBAAkB,mBAAmB,CA4DvC,CAAA"}

package/dist/field/features/blocks/populationPromise.js

@@ -1,46 +0,0 @@
-import { sanitizeFields } from 'payload/config';
-import { recurseNestedFields } from '../../../populate/recurseNestedFields.js';
-export const blockPopulationPromiseHOC = (props)=>{
-    const blockPopulationPromise = ({ context, currentDepth, depth, editorPopulationPromises, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
-        const blocks = props.blocks;
-        const blockFieldData = node.fields;
-        const promises = [];
-        // Sanitize block's fields here. This is done here and not in the feature, because the payload config is available here
-        const payloadConfig = req.payload.config;
-        const validRelationships = payloadConfig.collections.map((c)=>c.slug) || [];
-        blocks.forEach((block)=>{
-            block.fields = sanitizeFields({
-                config: payloadConfig,
-                fields: block.fields,
-                requireFieldLevelRichTextEditor: true,
-                validRelationships
-            });
-        });
-        // find block used in this node
-        const block = props.blocks.find((block)=>block.slug === blockFieldData.blockType);
-        if (!block || !block?.fields?.length || !blockFieldData) {
-            return promises;
-        }
-        recurseNestedFields({
-            context,
-            currentDepth,
-            data: blockFieldData,
-            depth,
-            editorPopulationPromises,
-            fields: block.fields,
-            findMany,
-            flattenLocales,
-            overrideAccess,
-            populationPromises,
-            promises,
-            req,
-            showHiddenFields,
-            // The afterReadPromise gets its data from looking for field.name inside the siblingDoc. Thus, here we cannot pass the whole document's siblingDoc, but only the siblingDoc (sibling fields) of the current field.
-            siblingDoc: blockFieldData
-        });
-        return promises;
-    };
-    return blockPopulationPromise;
-};
-
-//# sourceMappingURL=populationPromise.js.map

package/dist/field/features/blocks/populationPromise.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/blocks/populationPromise.ts"],"sourcesContent":["import type { Block } from 'payload/types'\n\nimport { sanitizeFields } from 'payload/config'\n\nimport type { PopulationPromise } from '../types.js'\nimport type { BlocksFeatureProps } from './feature.server.js'\nimport type { SerializedBlockNode } from './nodes/BlocksNode.js'\n\nimport { recurseNestedFields } from '../../../populate/recurseNestedFields.js'\n\nexport const blockPopulationPromiseHOC = (\n  props: BlocksFeatureProps,\n): PopulationPromise<SerializedBlockNode> => {\n  const blockPopulationPromise: PopulationPromise<SerializedBlockNode> = ({\n    context,\n    currentDepth,\n    depth,\n    editorPopulationPromises,\n    findMany,\n    flattenLocales,\n    node,\n    overrideAccess,\n    populationPromises,\n    req,\n    showHiddenFields,\n    siblingDoc,\n  }) => {\n    const blocks: Block[] = props.blocks\n    const blockFieldData = node.fields\n\n    const promises: Promise<void>[] = []\n\n    // Sanitize block's fields here. This is done here and not in the feature, because the payload config is available here\n    const payloadConfig = req.payload.config\n    const validRelationships = payloadConfig.collections.map((c) => c.slug) || []\n    blocks.forEach((block) => {\n      block.fields = sanitizeFields({\n        config: payloadConfig,\n        fields: block.fields,\n        requireFieldLevelRichTextEditor: true,\n        validRelationships,\n      })\n    })\n\n    // find block used in this node\n    const block = props.blocks.find((block) => block.slug === blockFieldData.blockType)\n    if (!block || !block?.fields?.length || !blockFieldData) {\n      return promises\n    }\n\n    recurseNestedFields({\n      context,\n      currentDepth,\n      data: blockFieldData,\n      depth,\n      editorPopulationPromises,\n      fields: block.fields,\n      findMany,\n      flattenLocales,\n      overrideAccess,\n      populationPromises,\n      promises,\n      req,\n      showHiddenFields,\n      // The afterReadPromise gets its data from looking for field.name inside the siblingDoc. Thus, here we cannot pass the whole document's siblingDoc, but only the siblingDoc (sibling fields) of the current field.\n      siblingDoc: blockFieldData,\n    })\n\n    return promises\n  }\n\n  return blockPopulationPromise\n}\n"],"names":["sanitizeFields","recurseNestedFields","blockPopulationPromiseHOC","props","blockPopulationPromise","context","currentDepth","depth","editorPopulationPromises","findMany","flattenLocales","node","overrideAccess","populationPromises","req","showHiddenFields","siblingDoc","blocks","blockFieldData","fields","promises","payloadConfig","payload","config","validRelationships","collections","map","c","slug","forEach","block","requireFieldLevelRichTextEditor","find","blockType","length","data"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAM/C,SAASC,mBAAmB,QAAQ,2CAA0C;AAE9E,OAAO,MAAMC,4BAA4B,CACvCC;IAEA,MAAMC,yBAAiE,CAAC,EACtEC,OAAO,EACPC,YAAY,EACZC,KAAK,EACLC,wBAAwB,EACxBC,QAAQ,EACRC,cAAc,EACdC,IAAI,EACJC,cAAc,EACdC,kBAAkB,EAClBC,GAAG,EACHC,gBAAgB,EAChBC,UAAU,EACX;QACC,MAAMC,SAAkBd,MAAMc,MAAM;QACpC,MAAMC,iBAAiBP,KAAKQ,MAAM;QAElC,MAAMC,WAA4B,EAAE;QAEpC,uHAAuH;QACvH,MAAMC,gBAAgBP,IAAIQ,OAAO,CAACC,MAAM;QACxC,MAAMC,qBAAqBH,cAAcI,WAAW,CAACC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;QAC7EX,OAAOY,OAAO,CAAC,CAACC;YACdA,MAAMX,MAAM,GAAGnB,eAAe;gBAC5BuB,QAAQF;gBACRF,QAAQW,MAAMX,MAAM;gBACpBY,iCAAiC;gBACjCP;YACF;QACF;QAEA,+BAA+B;QAC/B,MAAMM,QAAQ3B,MAAMc,MAAM,CAACe,IAAI,CAAC,CAACF,QAAUA,MAAMF,IAAI,KAAKV,eAAee,SAAS;QAClF,IAAI,CAACH,SAAS,CAACA,OAAOX,QAAQe,UAAU,CAAChB,gBAAgB;YACvD,OAAOE;QACT;QAEAnB,oBAAoB;YAClBI;YACAC;YACA6B,MAAMjB;YACNX;YACAC;YACAW,QAAQW,MAAMX,MAAM;YACpBV;YACAC;YACAE;YACAC;YACAO;YACAN;YACAC;YACA,kNAAkN;YAClNC,YAAYE;QACd;QAEA,OAAOE;IACT;IAEA,OAAOhB;AACT,EAAC"}

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

@@ -1,5 +0,0 @@
-import type { NodeValidation } from '../types.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/field/features/blocks/validate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/field/features/blocks/validate.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE,eAAO,MAAM,kBAAkB,UACtB,kBAAkB,KACxB,eAAe,mBAAmB,CAmEpC,CAAA"}

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

@@ -1,50 +0,0 @@
-import { sanitizeFields } from 'payload/config';
-export const blockValidationHOC = (props)=>{
-    const blockValidation = async ({ node, validation })=>{
-        const blockFieldData = node.fields;
-        const blocks = props.blocks;
-        const { options: { req, req: { payload: { config } } } } = validation;
-        // Sanitize block's fields here. This is done here and not in the feature, because the payload config is available here
-        const validRelationships = config.collections.map((c)=>c.slug) || [];
-        blocks.forEach((block)=>{
-            block.fields = sanitizeFields({
-                config,
-                fields: block.fields,
-                requireFieldLevelRichTextEditor: true,
-                validRelationships
-            });
-        });
-        // find block
-        const block = props.blocks.find((block)=>block.slug === blockFieldData.blockType);
-        // validate block
-        if (!block) {
-            return 'Block not found';
-        }
-        for (const field of block.fields){
-            if ('validate' in field && typeof field.validate === 'function' && field.validate) {
-                const fieldValue = 'name' in field ? node.fields[field.name] : null;
-                const passesCondition = field.admin?.condition ? Boolean(field.admin.condition(fieldValue, node.fields, {
-                    user: req?.user
-                })) : true;
-                if (!passesCondition) {
-                    continue; // Fixes https://github.com/payloadcms/payload/issues/4000
-                }
-                const validationResult = await field.validate(fieldValue, {
-                    ...field,
-                    id: validation.options.id,
-                    data: fieldValue,
-                    operation: validation.options.operation,
-                    req,
-                    siblingData: validation.options.siblingData
-                });
-                if (validationResult !== true) {
-                    return validationResult;
-                }
-            }
-        }
-        return true;
-    };
-    return blockValidation;
-};
-
-//# sourceMappingURL=validate.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/field/features/blocks/validate.ts"],"sourcesContent":["import type { Block } from 'payload/types'\n\nimport { sanitizeFields } from 'payload/config'\n\nimport type { NodeValidation } from '../types.js'\nimport type { BlocksFeatureProps } from './feature.server.js'\nimport type { SerializedBlockNode } from './nodes/BlocksNode.js'\n\nexport const blockValidationHOC = (\n  props: BlocksFeatureProps,\n): NodeValidation<SerializedBlockNode> => {\n  const blockValidation: NodeValidation<SerializedBlockNode> = async ({ node, validation }) => {\n    const blockFieldData = node.fields\n    const blocks: Block[] = props.blocks\n\n    const {\n      options: {\n        req,\n        req: {\n          payload: { config },\n        },\n      },\n    } = validation\n\n    // Sanitize block's fields here. This is done here and not in the feature, because the payload config is available here\n    const validRelationships = config.collections.map((c) => c.slug) || []\n    blocks.forEach((block) => {\n      block.fields = sanitizeFields({\n        config,\n        fields: block.fields,\n        requireFieldLevelRichTextEditor: true,\n        validRelationships,\n      })\n    })\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    for (const field of block.fields) {\n      if ('validate' in field && typeof field.validate === 'function' && field.validate) {\n        const fieldValue = 'name' in field ? node.fields[field.name] : null\n\n        const passesCondition = field.admin?.condition\n          ? Boolean(\n              field.admin.condition(fieldValue, node.fields, {\n                user: req?.user,\n              }),\n            )\n          : true\n        if (!passesCondition) {\n          continue // Fixes https://github.com/payloadcms/payload/issues/4000\n        }\n\n        const validationResult = await field.validate(fieldValue, {\n          ...field,\n          id: validation.options.id,\n          data: fieldValue,\n          operation: validation.options.operation,\n          req,\n          siblingData: validation.options.siblingData,\n        })\n\n        if (validationResult !== true) {\n          return validationResult\n        }\n      }\n    }\n\n    return true\n  }\n\n  return blockValidation\n}\n"],"names":["sanitizeFields","blockValidationHOC","props","blockValidation","node","validation","blockFieldData","fields","blocks","options","req","payload","config","validRelationships","collections","map","c","slug","forEach","block","requireFieldLevelRichTextEditor","find","blockType","field","validate","fieldValue","name","passesCondition","admin","condition","Boolean","user","validationResult","id","data","operation","siblingData"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAM/C,OAAO,MAAMC,qBAAqB,CAChCC;IAEA,MAAMC,kBAAuD,OAAO,EAAEC,IAAI,EAAEC,UAAU,EAAE;QACtF,MAAMC,iBAAiBF,KAAKG,MAAM;QAClC,MAAMC,SAAkBN,MAAMM,MAAM;QAEpC,MAAM,EACJC,SAAS,EACPC,GAAG,EACHA,KAAK,EACHC,SAAS,EAAEC,MAAM,EAAE,EACpB,EACF,EACF,GAAGP;QAEJ,uHAAuH;QACvH,MAAMQ,qBAAqBD,OAAOE,WAAW,CAACC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAK,EAAE;QACtET,OAAOU,OAAO,CAAC,CAACC;YACdA,MAAMZ,MAAM,GAAGP,eAAe;gBAC5BY;gBACAL,QAAQY,MAAMZ,MAAM;gBACpBa,iCAAiC;gBACjCP;YACF;QACF;QAEA,aAAa;QACb,MAAMM,QAAQjB,MAAMM,MAAM,CAACa,IAAI,CAAC,CAACF,QAAUA,MAAMF,IAAI,KAAKX,eAAegB,SAAS;QAElF,iBAAiB;QACjB,IAAI,CAACH,OAAO;YACV,OAAO;QACT;QAEA,KAAK,MAAMI,SAASJ,MAAMZ,MAAM,CAAE;YAChC,IAAI,cAAcgB,SAAS,OAAOA,MAAMC,QAAQ,KAAK,cAAcD,MAAMC,QAAQ,EAAE;gBACjF,MAAMC,aAAa,UAAUF,QAAQnB,KAAKG,MAAM,CAACgB,MAAMG,IAAI,CAAC,GAAG;gBAE/D,MAAMC,kBAAkBJ,MAAMK,KAAK,EAAEC,YACjCC,QACEP,MAAMK,KAAK,CAACC,SAAS,CAACJ,YAAYrB,KAAKG,MAAM,EAAE;oBAC7CwB,MAAMrB,KAAKqB;gBACb,MAEF;gBACJ,IAAI,CAACJ,iBAAiB;oBACpB,UAAS,0DAA0D;gBACrE;gBAEA,MAAMK,mBAAmB,MAAMT,MAAMC,QAAQ,CAACC,YAAY;oBACxD,GAAGF,KAAK;oBACRU,IAAI5B,WAAWI,OAAO,CAACwB,EAAE;oBACzBC,MAAMT;oBACNU,WAAW9B,WAAWI,OAAO,CAAC0B,SAAS;oBACvCzB;oBACA0B,aAAa/B,WAAWI,OAAO,CAAC2B,WAAW;gBAC7C;gBAEA,IAAIJ,qBAAqB,MAAM;oBAC7B,OAAOA;gBACT;YACF;QACF;QAEA,OAAO;IACT;IAEA,OAAO7B;AACT,EAAC"}

package/dist/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.d.ts

@@ -1,3 +0,0 @@
-import type { FloatingToolbarSection, FloatingToolbarSectionEntry } from '../../../lexical/plugins/FloatingSelectToolbar/types.js';
-export declare const FeaturesSectionWithEntries: (entries: FloatingToolbarSectionEntry[]) => FloatingToolbarSection;
-//# sourceMappingURL=index.d.ts.map

package/dist/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,yDAAyD,CAAA;AAEhE,eAAO,MAAM,0BAA0B,YAC5B,2BAA2B,EAAE,KACrC,sBAOF,CAAA"}

package/dist/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.js

@@ -1,10 +0,0 @@
-export const FeaturesSectionWithEntries = (entries)=>{
-    return {
-        type: 'buttons',
-        entries,
-        key: 'features',
-        order: 5
-    };
-};
-
-//# sourceMappingURL=index.js.map

package/dist/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.ts"],"sourcesContent":["import type {\n  FloatingToolbarSection,\n  FloatingToolbarSectionEntry,\n} from '../../../lexical/plugins/FloatingSelectToolbar/types.js'\n\nexport const FeaturesSectionWithEntries = (\n  entries: FloatingToolbarSectionEntry[],\n): FloatingToolbarSection => {\n  return {\n    type: 'buttons',\n    entries,\n    key: 'features',\n    order: 5,\n  }\n}\n"],"names":["FeaturesSectionWithEntries","entries","type","key","order"],"rangeMappings":";;;;;;;","mappings":"AAKA,OAAO,MAAMA,6BAA6B,CACxCC;IAEA,OAAO;QACLC,MAAM;QACND;QACAE,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/common/floatingSelectToolbarTextDropdownSection/index.d.ts

@@ -1,3 +0,0 @@
-import type { FloatingToolbarSection, FloatingToolbarSectionEntry } from '../../../lexical/plugins/FloatingSelectToolbar/types.js';
-export declare const TextDropdownSectionWithEntries: (entries: FloatingToolbarSectionEntry[]) => FloatingToolbarSection;
-//# sourceMappingURL=index.d.ts.map

package/dist/field/features/common/floatingSelectToolbarTextDropdownSection/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/common/floatingSelectToolbarTextDropdownSection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,yDAAyD,CAAA;AAIhE,eAAO,MAAM,8BAA8B,YAChC,2BAA2B,EAAE,KACrC,sBAQF,CAAA"}

package/dist/field/features/common/floatingSelectToolbarTextDropdownSection/index.js

@@ -1,12 +0,0 @@
-import { TextIcon } from '../../../lexical/ui/icons/Text/index.js';
-export const TextDropdownSectionWithEntries = (entries)=>{
-    return {
-        type: 'dropdown',
-        ChildComponent: TextIcon,
-        entries,
-        key: 'dropdown-text',
-        order: 1
-    };
-};
-
-//# sourceMappingURL=index.js.map

package/dist/field/features/common/floatingSelectToolbarTextDropdownSection/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/features/common/floatingSelectToolbarTextDropdownSection/index.ts"],"sourcesContent":["import type {\n  FloatingToolbarSection,\n  FloatingToolbarSectionEntry,\n} from '../../../lexical/plugins/FloatingSelectToolbar/types.js'\n\nimport { TextIcon } from '../../../lexical/ui/icons/Text/index.js'\n\nexport const TextDropdownSectionWithEntries = (\n  entries: FloatingToolbarSectionEntry[],\n): FloatingToolbarSection => {\n  return {\n    type: 'dropdown',\n    ChildComponent: TextIcon,\n    entries,\n    key: 'dropdown-text',\n    order: 1,\n  }\n}\n"],"names":["TextIcon","TextDropdownSectionWithEntries","entries","type","ChildComponent","key","order"],"rangeMappings":";;;;;;;;;","mappings":"AAKA,SAASA,QAAQ,QAAQ,0CAAyC;AAElE,OAAO,MAAMC,iCAAiC,CAC5CC;IAEA,OAAO;QACLC,MAAM;QACNC,gBAAgBJ;QAChBE;QACAG,KAAK;QACLC,OAAO;IACT;AACF,EAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"linebreak.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/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/field/features/converters/html/converter/converters/linebreak.js

@@ -1,10 +0,0 @@
-export const LinebreakHTMLConverter = {
-    converter () {
-        return `<br>`;
-    },
-    nodeTypes: [
-        'linebreak'
-    ]
-};
-
-//# sourceMappingURL=linebreak.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../src/field/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"],"rangeMappings":";;;;;;;","mappings":"AAIA,OAAO,MAAMA,yBAAiE;IAC5EC;QACE,OAAO,CAAC,IAAI,CAAC;IACf;IACAC,WAAW;QAAC;KAAY;AAC1B,EAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/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/field/features/converters/html/converter/converters/paragraph.js

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../src/field/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, payload }) {\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: node.children,\n      parent: {\n        ...node,\n        parent,\n      },\n      payload,\n    })\n    return `<p>${childrenText}</p>`\n  },\n  nodeTypes: ['paragraph'],\n}\n"],"names":["convertLexicalNodesToHTML","ParagraphHTMLConverter","converter","converters","node","parent","payload","childrenText","lexicalNodes","children","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,yBAAyB,QAAQ,cAAa;AAEvD,OAAO,MAAMC,yBAAiE;IAC5E,MAAMC,WAAU,EAAEC,UAAU,EAAEC,IAAI,EAAEC,MAAM,EAAEC,OAAO,EAAE;QACnD,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/field/features/converters/html/converter/converters/text.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/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/field/features/converters/html/converter/converters/text.js

@@ -1,33 +0,0 @@
-import { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js';
-export const TextHTMLConverter = {
-    converter ({ 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;
-    },
-    nodeTypes: [
-        'text'
-    ]
-};
-
-//# sourceMappingURL=text.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../src/field/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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","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/field/features/converters/html/converter/defaultConverters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../../src/field/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/field/features/converters/html/converter/defaultConverters.js

@@ -1,10 +0,0 @@
-import { LinebreakHTMLConverter } from './converters/linebreak.js';
-import { ParagraphHTMLConverter } from './converters/paragraph.js';
-import { TextHTMLConverter } from './converters/text.js';
-export const defaultHTMLConverters = [
-    ParagraphHTMLConverter,
-    TextHTMLConverter,
-    LinebreakHTMLConverter
-];
-
-//# sourceMappingURL=defaultConverters.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/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"],"rangeMappings":";;;;;;;","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/field/features/converters/html/converter/index.d.ts

@@ -1,21 +0,0 @@
-import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-import type { Payload } from 'payload';
-import type { HTMLConverter, SerializedLexicalNodeWithParent } from './types.js';
-export declare function convertLexicalToHTML({ converters, data, payload, }: {
-    converters: HTMLConverter[];
-    data: SerializedEditorState;
-    /**
-     * When the converter is called, payload CAN be passed in depending on where it's run.
-     */
-    payload: Payload | null;
-}): Promise<string>;
-export declare function convertLexicalNodesToHTML({ converters, lexicalNodes, parent, payload, }: {
-    converters: HTMLConverter[];
-    lexicalNodes: SerializedLexicalNode[];
-    parent: SerializedLexicalNodeWithParent;
-    /**
-     * When the converter is called, payload CAN be passed in depending on where it's run.
-     */
-    payload: Payload | null;
-}): Promise<string>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/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,MAAM,SAAS,CAAA;AAEtC,OAAO,KAAK,EAAE,aAAa,EAAE,+BAA+B,EAAE,MAAM,YAAY,CAAA;AAEhF,wBAAsB,oBAAoB,CAAC,EACzC,UAAU,EACV,IAAI,EACJ,OAAO,GACR,EAAE;IACD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,IAAI,EAAE,qBAAqB,CAAA;IAC3B;;OAEG;IACH,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAUlB;AAED,wBAAsB,yBAAyB,CAAC,EAC9C,UAAU,EACV,YAAY,EACZ,MAAM,EACN,OAAO,GACR,EAAE;IACD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,EAAE,qBAAqB,EAAE,CAAA;IACrC,MAAM,EAAE,+BAA+B,CAAA;IACvC;;OAEG;IACH,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAoClB"}

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

@@ -1,44 +0,0 @@
-export async function convertLexicalToHTML({ converters, data, payload }) {
-    if (data?.root?.children?.length) {
-        return await convertLexicalNodesToHTML({
-            converters,
-            lexicalNodes: data?.root?.children,
-            parent: data?.root,
-            payload
-        });
-    }
-    return '';
-}
-export async function convertLexicalNodesToHTML({ converters, lexicalNodes, parent, payload }) {
-    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,
-                        payload
-                    });
-                }
-                return '<span>unknown node</span>';
-            }
-            return await converterForNode.converter({
-                childIndex: i,
-                converters,
-                node,
-                parent,
-                payload
-            });
-        } catch (error) {
-            console.error('Error converting lexical node to HTML:', error, 'node:', node);
-            return '';
-        }
-    }));
-    return htmlArray.join('') || '';
-}
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/features/converters/html/converter/index.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\nimport type { Payload } from 'payload'\n\nimport type { HTMLConverter, SerializedLexicalNodeWithParent } from './types.js'\n\nexport async function convertLexicalToHTML({\n  converters,\n  data,\n  payload,\n}: {\n  converters: HTMLConverter[]\n  data: SerializedEditorState\n  /**\n   * When the converter is called, payload CAN be passed in depending on where it's run.\n   */\n  payload: Payload | null\n}): Promise<string> {\n  if (data?.root?.children?.length) {\n    return await convertLexicalNodesToHTML({\n      converters,\n      lexicalNodes: data?.root?.children,\n      parent: data?.root,\n      payload,\n    })\n  }\n  return ''\n}\n\nexport async function convertLexicalNodesToHTML({\n  converters,\n  lexicalNodes,\n  parent,\n  payload,\n}: {\n  converters: HTMLConverter[]\n  lexicalNodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n  /**\n   * When the converter is called, payload CAN be passed in depending on where it's run.\n   */\n  payload: Payload | 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              payload,\n            })\n          }\n          return '<span>unknown node</span>'\n        }\n        return await converterForNode.converter({\n          childIndex: i,\n          converters,\n          node,\n          parent,\n          payload,\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":["convertLexicalToHTML","converters","data","payload","root","children","length","convertLexicalNodesToHTML","lexicalNodes","parent","unknownConverter","find","converter","nodeTypes","includes","htmlArray","Promise","all","map","node","i","converterForNode","type","childIndex","error","console","join"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,OAAO,eAAeA,qBAAqB,EACzCC,UAAU,EACVC,IAAI,EACJC,OAAO,EAQR;IACC,IAAID,MAAME,MAAMC,UAAUC,QAAQ;QAChC,OAAO,MAAMC,0BAA0B;YACrCN;YACAO,cAAcN,MAAME,MAAMC;YAC1BI,QAAQP,MAAME;YACdD;QACF;IACF;IACA,OAAO;AACT;AAEA,OAAO,eAAeI,0BAA0B,EAC9CN,UAAU,EACVO,YAAY,EACZC,MAAM,EACNN,OAAO,EASR;IACC,MAAMO,mBAAmBT,WAAWU,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IAErF,MAAMC,YAAY,MAAMC,QAAQC,GAAG,CACjCT,aAAaU,GAAG,CAAC,OAAOC,MAAMC;QAC5B,MAAMC,mBAAmBpB,WAAWU,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;wBACZnB;wBACAkB;wBACAV;wBACAN;oBACF;gBACF;gBACA,OAAO;YACT;YACA,OAAO,MAAMkB,iBAAiBT,SAAS,CAAC;gBACtCW,YAAYH;gBACZnB;gBACAkB;gBACAV;gBACAN;YACF;QACF,EAAE,OAAOqB,OAAO;YACdC,QAAQD,KAAK,CAAC,0CAA0CA,OAAO,SAASL;YACxE,OAAO;QACT;IACF;IAGF,OAAOJ,UAAUW,IAAI,CAAC,OAAO;AAC/B"}

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

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