@payloadcms/richtext-lexical 3.0.0-canary.3bd3027 → 3.0.0-canary.483db21

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

@@ -1,4 +1,4 @@
-import type { PluginComponent } from '../../types.js';
+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'>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/plugin/index.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/plugin/index.tsx"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAwB,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACjF,OAAO,KAAK,EAAE,wBAAwB,EAAe,MAAM,sBAAsB,CAAA;AACjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAazD,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;AAI3D,eAAO,MAAM,YAAY,EAAE,eAAe,CAAC,wBAAwB,CAyIlE,CAAA"}

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

@@ -1,14 +1,26 @@
 '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 { $insertNodeToNearestRoot, $wrapNodeInElement, mergeRegister } from '@lexical/utils';
+import { getTranslation } from '@payloadcms/translations';
+import { useModal, useTranslation } from '@payloadcms/ui';
+import { $createParagraphNode, $getNodeByKey, $getPreviousSelection, $getSelection, $insertNodes, $isParagraphNode, $isRangeSelection, $isRootOrShadowRoot, COMMAND_PRIORITY_EDITOR } from 'lexical';
+import React, { useEffect, useState } from 'react';
+import { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider.js';
+import { FieldsDrawer } from '../../../utilities/fieldsDrawer/Drawer.js';
 import { $createBlockNode, BlockNode } from '../nodes/BlocksNode.js';
-import { INSERT_BLOCK_COMMAND } from './commands.js';
+import { $createInlineBlockNode } from '../nodes/InlineBlocksNode.js';
+import { INSERT_BLOCK_COMMAND, INSERT_INLINE_BLOCK_COMMAND, OPEN_INLINE_BLOCK_DRAWER_COMMAND } from './commands.js';
+const drawerSlug = 'lexical-inlineBlocks-create';
 export const BlocksPlugin = ()=>{
     const [editor] = useLexicalComposerContext();
+    const { closeModal, toggleModal } = useModal();
+    const [blockFields, setBlockFields] = useState(null);
+    const [blockType, setBlockType] = useState('');
+    const [targetNodeKey, setTargetNodeKey] = useState(null);
+    const { i18n, t } = useTranslation();
+    const { editorConfig } = useEditorConfigContext();
+    const reducedBlock = editorConfig?.resolvedFeatureMap?.get('blocks')?.sanitizedClientFeatureProps?.reducedInlineBlocks?.find((block)=>block.slug === blockFields?.blockType);
     useEffect(()=>{
         if (!editor.hasNodes([
             BlockNode
@@ -32,11 +44,68 @@ export const BlocksPlugin = ()=>{
                 }
             });
             return true;
+        }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(INSERT_INLINE_BLOCK_COMMAND, (fields)=>{
+            if (targetNodeKey) {
+                const node = $getNodeByKey(targetNodeKey);
+                if (!node) {
+                    return false;
+                }
+                node.setFields(fields);
+                setTargetNodeKey(null);
+                return true;
+            }
+            const inlineBlockNode = $createInlineBlockNode(fields);
+            $insertNodes([
+                inlineBlockNode
+            ]);
+            if ($isRootOrShadowRoot(inlineBlockNode.getParentOrThrow())) {
+                $wrapNodeInElement(inlineBlockNode, $createParagraphNode).selectEnd();
+            }
+            return true;
+        }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(OPEN_INLINE_BLOCK_DRAWER_COMMAND, ({ fields, nodeKey })=>{
+            setBlockFields(fields ?? null);
+            setTargetNodeKey(nodeKey ?? null);
+            setBlockType(fields?.blockType ?? '');
+            if (nodeKey) {
+                toggleModal(drawerSlug);
+                return true;
+            }
+            let rangeSelection = null;
+            editor.getEditorState().read(()=>{
+                const selection = $getSelection();
+                if ($isRangeSelection(selection)) {
+                    rangeSelection = selection;
+                }
+            });
+            if (rangeSelection) {
+                //setLastSelection(rangeSelection)
+                toggleModal(drawerSlug);
+            }
+            return true;
         }, COMMAND_PRIORITY_EDITOR));
     }, [
-        editor
+        editor,
+        targetNodeKey,
+        toggleModal
     ]);
-    return /*#__PURE__*/ _jsx(BlocksDrawerComponent, {});
+    const blockDisplayName = reducedBlock?.labels?.singular ? getTranslation(reducedBlock?.labels?.singular, i18n) : reducedBlock?.slug;
+    return /*#__PURE__*/ _jsx(FieldsDrawer, {
+        data: blockFields,
+        drawerSlug: drawerSlug,
+        drawerTitle: t(`lexical:blocks:inlineBlocks:${blockFields?.id ? 'edit' : 'create'}`, {
+            label: blockDisplayName ?? t('lexical:blocks:inlineBlocks:label')
+        }),
+        featureKey: "blocks",
+        handleDrawerSubmit: (_fields, data)=>{
+            closeModal(drawerSlug);
+            if (!data) {
+                return;
+            }
+            data.blockType = blockType;
+            editor.dispatchCommand(INSERT_INLINE_BLOCK_COMMAND, data);
+        },
+        schemaPathSuffix: blockFields?.blockType
+    });
 };
 
 //# sourceMappingURL=index.js.map

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

@@ -1 +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 '../../types.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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","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"}
+{"version":3,"sources":["../../../../src/features/blocks/plugin/index.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { $insertNodeToNearestRoot, $wrapNodeInElement, mergeRegister } from '@lexical/utils'\nimport { getTranslation } from '@payloadcms/translations'\nimport { useModal, useTranslation } from '@payloadcms/ui'\nimport {\n  $createParagraphNode,\n  $getNodeByKey,\n  $getPreviousSelection,\n  $getSelection,\n  $insertNodes,\n  $isParagraphNode,\n  $isRangeSelection,\n  $isRootOrShadowRoot,\n  COMMAND_PRIORITY_EDITOR,\n  type RangeSelection,\n} from 'lexical'\nimport React, { useEffect, useState } from 'react'\n\nimport type { ClientComponentProps, PluginComponent } from '../../typesClient.js'\nimport type { BlocksFeatureClientProps, ClientBlock } from '../feature.client.js'\nimport type { BlockFields } from '../nodes/BlocksNode.js'\nimport type { InlineBlockNode } from '../nodes/InlineBlocksNode.js'\n\nimport { useEditorConfigContext } from '../../../lexical/config/client/EditorConfigProvider.js'\nimport { FieldsDrawer } from '../../../utilities/fieldsDrawer/Drawer.js'\nimport { $createBlockNode, BlockNode } from '../nodes/BlocksNode.js'\nimport { $createInlineBlockNode } from '../nodes/InlineBlocksNode.js'\nimport {\n  INSERT_BLOCK_COMMAND,\n  INSERT_INLINE_BLOCK_COMMAND,\n  OPEN_INLINE_BLOCK_DRAWER_COMMAND,\n} from './commands.js'\n\nexport type InsertBlockPayload = Exclude<BlockFields, 'id'>\n\nconst drawerSlug = 'lexical-inlineBlocks-create'\n\nexport const BlocksPlugin: PluginComponent<BlocksFeatureClientProps> = () => {\n  const [editor] = useLexicalComposerContext()\n  const { closeModal, toggleModal } = useModal()\n  const [blockFields, setBlockFields] = useState<BlockFields>(null)\n  const [blockType, setBlockType] = useState<string>('' as any)\n  const [targetNodeKey, setTargetNodeKey] = useState<null | string>(null)\n  const { i18n, t } = useTranslation<string, any>()\n\n  const { editorConfig } = useEditorConfigContext()\n\n  const reducedBlock: ClientBlock = (\n    editorConfig?.resolvedFeatureMap?.get('blocks')\n      ?.sanitizedClientFeatureProps as ClientComponentProps<BlocksFeatureClientProps>\n  )?.reducedInlineBlocks?.find((block) => block.slug === blockFields?.blockType)\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      editor.registerCommand(\n        INSERT_INLINE_BLOCK_COMMAND,\n        (fields) => {\n          if (targetNodeKey) {\n            const node: InlineBlockNode = $getNodeByKey(targetNodeKey)\n\n            if (!node) {\n              return false\n            }\n\n            node.setFields(fields as BlockFields)\n\n            setTargetNodeKey(null)\n            return true\n          }\n\n          const inlineBlockNode = $createInlineBlockNode(fields as BlockFields)\n          $insertNodes([inlineBlockNode])\n          if ($isRootOrShadowRoot(inlineBlockNode.getParentOrThrow())) {\n            $wrapNodeInElement(inlineBlockNode, $createParagraphNode).selectEnd()\n          }\n\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n      editor.registerCommand(\n        OPEN_INLINE_BLOCK_DRAWER_COMMAND,\n        ({ fields, nodeKey }) => {\n          setBlockFields((fields as BlockFields) ?? null)\n          setTargetNodeKey(nodeKey ?? null)\n          setBlockType(fields?.blockType ?? ('' as any))\n\n          if (nodeKey) {\n            toggleModal(drawerSlug)\n            return true\n          }\n\n          let rangeSelection: RangeSelection | null = null\n\n          editor.getEditorState().read(() => {\n            const selection = $getSelection()\n            if ($isRangeSelection(selection)) {\n              rangeSelection = selection\n            }\n          })\n\n          if (rangeSelection) {\n            //setLastSelection(rangeSelection)\n            toggleModal(drawerSlug)\n          }\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n    )\n  }, [editor, targetNodeKey, toggleModal])\n\n  const blockDisplayName = reducedBlock?.labels?.singular\n    ? getTranslation(reducedBlock?.labels?.singular, i18n)\n    : reducedBlock?.slug\n\n  return (\n    <FieldsDrawer\n      data={blockFields}\n      drawerSlug={drawerSlug}\n      drawerTitle={t(`lexical:blocks:inlineBlocks:${blockFields?.id ? 'edit' : 'create'}`, {\n        label: blockDisplayName ?? t('lexical:blocks:inlineBlocks:label'),\n      })}\n      featureKey=\"blocks\"\n      handleDrawerSubmit={(_fields, data) => {\n        closeModal(drawerSlug)\n        if (!data) {\n          return\n        }\n\n        data.blockType = blockType\n\n        editor.dispatchCommand(INSERT_INLINE_BLOCK_COMMAND, data)\n      }}\n      schemaPathSuffix={blockFields?.blockType}\n    />\n  )\n}\n"],"names":["useLexicalComposerContext","$insertNodeToNearestRoot","$wrapNodeInElement","mergeRegister","getTranslation","useModal","useTranslation","$createParagraphNode","$getNodeByKey","$getPreviousSelection","$getSelection","$insertNodes","$isParagraphNode","$isRangeSelection","$isRootOrShadowRoot","COMMAND_PRIORITY_EDITOR","React","useEffect","useState","useEditorConfigContext","FieldsDrawer","$createBlockNode","BlockNode","$createInlineBlockNode","INSERT_BLOCK_COMMAND","INSERT_INLINE_BLOCK_COMMAND","OPEN_INLINE_BLOCK_DRAWER_COMMAND","drawerSlug","BlocksPlugin","editor","closeModal","toggleModal","blockFields","setBlockFields","blockType","setBlockType","targetNodeKey","setTargetNodeKey","i18n","t","editorConfig","reducedBlock","resolvedFeatureMap","get","sanitizedClientFeatureProps","reducedInlineBlocks","find","block","slug","hasNodes","Error","registerCommand","payload","update","selection","blockNode","focus","focusNode","getNode","getTextContentSize","getParent","getChildren","filter","node","length","remove","fields","setFields","inlineBlockNode","getParentOrThrow","selectEnd","nodeKey","rangeSelection","getEditorState","read","blockDisplayName","labels","singular","data","drawerTitle","id","label","featureKey","handleDrawerSubmit","_fields","dispatchCommand","schemaPathSuffix"],"mappings":"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"}

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

@@ -1,5 +1,6 @@
-import type { NodeValidation } from '../types.js';
-import type { BlocksFeatureProps } from './feature.server.js';
+import type { Block } from 'payload';
+import type { NodeValidation } from '../typesServer.js';
 import type { SerializedBlockNode } from './nodes/BlocksNode.js';
-export declare const blockValidationHOC: (props: BlocksFeatureProps) => NodeValidation<SerializedBlockNode>;
+import type { SerializedInlineBlockNode } from './nodes/InlineBlocksNode.js';
+export declare const blockValidationHOC: (blocks: Block[]) => NodeValidation<SerializedBlockNode | SerializedInlineBlockNode>;
 //# sourceMappingURL=validate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/features/blocks/validate.ts"],"names":[],"mappings":"AAEA,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;AAE7E,eAAO,MAAM,kBAAkB,UACtB,kBAAkB,KACxB,cAAc,CAAC,mBAAmB,CA2CpC,CAAA"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/features/blocks/validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAIpC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAe,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAC7E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAE5E,eAAO,MAAM,kBAAkB,WACrB,KAAK,EAAE,KACd,cAAc,CAAC,mBAAmB,GAAG,yBAAyB,CA4ChE,CAAA"}

package/dist/features/blocks/validate.js

@@ -1,10 +1,10 @@
 import { buildStateFromSchema } from '@payloadcms/ui/forms/buildStateFromSchema';
-export const blockValidationHOC = (props)=>{
+export const blockValidationHOC = (blocks)=>{
     return async ({ node, validation })=>{
         const blockFieldData = node.fields ?? {};
-        const { options: { id, operation, preferences, req } } = validation;
+        const { options: { id, collectionSlug, operation, preferences, req } } = validation;
         // find block
-        const block = props.blocks.find((block)=>block.slug === blockFieldData.blockType);
+        const block = blocks.find((block)=>block.slug === blockFieldData.blockType);
         // validate block
         if (!block) {
             return 'Block not found';
@@ -13,6 +13,7 @@ export const blockValidationHOC = (props)=>{
      * Run buildStateFromSchema as that properly validates block and block sub-fields
      */ const result = await buildStateFromSchema({
             id,
+            collectionSlug,
             data: blockFieldData,
             fieldSchema: block.fields,
             operation: operation === 'create' || operation === 'update' ? operation : 'update',

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/features/blocks/validate.ts"],"sourcesContent":["import { buildStateFromSchema } from '@payloadcms/ui/forms/buildStateFromSchema'\n\nimport type { NodeValidation } from '../types.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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","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"}
+{"version":3,"sources":["../../../src/features/blocks/validate.ts"],"sourcesContent":["import type { Block } from 'payload'\n\nimport { buildStateFromSchema } from '@payloadcms/ui/forms/buildStateFromSchema'\n\nimport type { NodeValidation } from '../typesServer.js'\nimport type { BlockFields, SerializedBlockNode } from './nodes/BlocksNode.js'\nimport type { SerializedInlineBlockNode } from './nodes/InlineBlocksNode.js'\n\nexport const blockValidationHOC = (\n  blocks: Block[],\n): NodeValidation<SerializedBlockNode | SerializedInlineBlockNode> => {\n  return async ({ node, validation }) => {\n    const blockFieldData = node.fields ?? ({} as BlockFields)\n\n    const {\n      options: { id, collectionSlug, operation, preferences, req },\n    } = validation\n\n    // find block\n    const block = 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      collectionSlug,\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","blocks","node","validation","blockFieldData","fields","options","id","collectionSlug","operation","preferences","req","block","find","slug","blockType","result","data","fieldSchema","siblingData","errorPaths","fieldKey","concat","length","join"],"mappings":"AAEA,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,cAAc,EAAEC,SAAS,EAAEC,WAAW,EAAEC,GAAG,EAAE,EAC7D,GAAGR;QAEJ,aAAa;QACb,MAAMS,QAAQX,OAAOY,IAAI,CAAC,CAACD,QAAUA,MAAME,IAAI,KAAKV,eAAeW,SAAS;QAE5E,iBAAiB;QACjB,IAAI,CAACH,OAAO;YACV,OAAO;QACT;QAEA;;KAEC,GAED,MAAMI,SAAS,MAAMjB,qBAAqB;YACxCQ;YACAC;YACAS,MAAMb;YACNc,aAAaN,MAAMP,MAAM;YACzBI,WAAWA,cAAc,YAAYA,cAAc,WAAWA,YAAY;YAC1EC;YACAC;YACAQ,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.js.map

@@ -1 +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"],"rangeMappings":";;;;;;;","mappings":"AAIA,OAAO,MAAMA,yBAAiE;IAC5EC;QACE,OAAO,CAAC,IAAI,CAAC;IACf;IACAC,WAAW;QAAC;KAAY;AAC1B,EAAC"}
+{"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

@@ -1 +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"}
+{"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,CAiBzE,CAAA"}

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

@@ -1,14 +1,17 @@
 import { convertLexicalNodesToHTML } from '../index.js';
 export const ParagraphHTMLConverter = {
-    async converter ({ converters, node, parent, req }) {
+    async converter ({ converters, draft, node, overrideAccess, parent, req, showHiddenFields }) {
         const childrenText = await convertLexicalNodesToHTML({
             converters,
+            draft,
             lexicalNodes: node.children,
+            overrideAccess,
             parent: {
                 ...node,
                 parent
             },
-            req
+            req,
+            showHiddenFields
         });
         return `<p>${childrenText}</p>`;
     },

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

@@ -1 +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"],"rangeMappings":";;;;;;;;;;;;;;;;;","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"}
+{"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, draft, node, overrideAccess, parent, req, showHiddenFields }) {\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      draft,\n      lexicalNodes: node.children,\n      overrideAccess,\n      parent: {\n        ...node,\n        parent,\n      },\n      req,\n      showHiddenFields,\n    })\n    return `<p>${childrenText}</p>`\n  },\n  nodeTypes: ['paragraph'],\n}\n"],"names":["convertLexicalNodesToHTML","ParagraphHTMLConverter","converter","converters","draft","node","overrideAccess","parent","req","showHiddenFields","childrenText","lexicalNodes","children","nodeTypes"],"mappings":"AAIA,SAASA,yBAAyB,QAAQ,cAAa;AAEvD,OAAO,MAAMC,yBAAiE;IAC5E,MAAMC,WAAU,EAAEC,UAAU,EAAEC,KAAK,EAAEC,IAAI,EAAEC,cAAc,EAAEC,MAAM,EAAEC,GAAG,EAAEC,gBAAgB,EAAE;QACxF,MAAMC,eAAe,MAAMV,0BAA0B;YACnDG;YACAC;YACAO,cAAcN,KAAKO,QAAQ;YAC3BN;YACAC,QAAQ;gBACN,GAAGF,IAAI;gBACPE;YACF;YACAC;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.js.map

@@ -1 +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"],"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"}
+{"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.js.map

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

@@ -4,6 +4,9 @@ import type { HTMLConverter, SerializedLexicalNodeWithParent } from './types.js'
 export type ConvertLexicalToHTMLArgs = {
     converters: HTMLConverter[];
     data: SerializedEditorState;
+    draft?: boolean;
+    overrideAccess?: boolean;
+    showHiddenFields?: boolean;
 } & ({
     /**
      * This payload property will only be used if req is undefined.
@@ -29,14 +32,17 @@ export type ConvertLexicalToHTMLArgs = {
      */
     req: PayloadRequest;
 });
-export declare function convertLexicalToHTML({ converters, data, payload, req, }: ConvertLexicalToHTMLArgs): Promise<string>;
-export declare function convertLexicalNodesToHTML({ converters, lexicalNodes, parent, req, }: {
+export declare function convertLexicalToHTML({ converters, data, draft, overrideAccess, payload, req, showHiddenFields, }: ConvertLexicalToHTMLArgs): Promise<string>;
+export declare function convertLexicalNodesToHTML({ converters, draft, lexicalNodes, overrideAccess, parent, req, showHiddenFields, }: {
     converters: HTMLConverter[];
+    draft: boolean;
     lexicalNodes: SerializedLexicalNode[];
+    overrideAccess: boolean;
     parent: SerializedLexicalNodeWithParent;
     /**
      * When the converter is called, req CAN be passed in depending on where it's run.
      */
     req: PayloadRequest | null;
+    showHiddenFields: boolean;
 }): Promise<string>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"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;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GAAG,CACA;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,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,KAAK,EACL,cAAc,EACd,OAAO,EACP,GAAG,EACH,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB5C;AAED,wBAAsB,yBAAyB,CAAC,EAC9C,UAAU,EACV,KAAK,EACL,YAAY,EACZ,cAAc,EACd,MAAM,EACN,GAAG,EACH,gBAAgB,GACjB,EAAE;IACD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,KAAK,EAAE,OAAO,CAAA;IACd,YAAY,EAAE,qBAAqB,EAAE,CAAA;IACrC,cAAc,EAAE,OAAO,CAAA;IACvB,MAAM,EAAE,+BAA+B,CAAA;IACvC;;OAEG;IACH,GAAG,EAAE,cAAc,GAAG,IAAI,CAAA;IAC1B,gBAAgB,EAAE,OAAO,CAAA;CAC1B,GAAG,OAAO,CAAC,MAAM,CAAC,CA0ClB"}

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

@@ -1,19 +1,22 @@
 import { createLocalReq } from 'payload';
-export async function convertLexicalToHTML({ converters, data, payload, req }) {
+export async function convertLexicalToHTML({ converters, data, draft, overrideAccess, payload, req, showHiddenFields }) {
     if (data?.root?.children?.length) {
         if (req === undefined && payload) {
             req = await createLocalReq({}, payload);
         }
         return await convertLexicalNodesToHTML({
             converters,
+            draft: draft === undefined ? false : draft,
             lexicalNodes: data?.root?.children,
+            overrideAccess: overrideAccess === undefined ? false : overrideAccess,
             parent: data?.root,
-            req
+            req,
+            showHiddenFields: showHiddenFields === undefined ? false : showHiddenFields
         });
     }
     return '';
 }
-export async function convertLexicalNodesToHTML({ converters, lexicalNodes, parent, req }) {
+export async function convertLexicalNodesToHTML({ converters, draft, lexicalNodes, overrideAccess, parent, req, showHiddenFields }) {
     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));
@@ -23,9 +26,12 @@ export async function convertLexicalNodesToHTML({ converters, lexicalNodes, pare
                     return await unknownConverter.converter({
                         childIndex: i,
                         converters,
+                        draft,
                         node,
+                        overrideAccess,
                         parent,
-                        req
+                        req,
+                        showHiddenFields
                     });
                 }
                 return '<span>unknown node</span>';
@@ -33,9 +39,12 @@ export async function convertLexicalNodesToHTML({ converters, lexicalNodes, pare
             return await converterForNode.converter({
                 childIndex: i,
                 converters,
+                draft,
                 node,
+                overrideAccess,
                 parent,
-                req
+                req,
+                showHiddenFields
             });
         } catch (error) {
             console.error('Error converting lexical node to HTML:', error, 'node:', node);

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

@@ -1 +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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","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"}
+{"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  draft?: boolean // default false\n  overrideAccess?: boolean // default false\n  showHiddenFields?: boolean // default false\n} & (\n  | {\n      /**\n       * This payload property will only be used if req is undefined.\n       */\n      payload?: 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  draft,\n  overrideAccess,\n  payload,\n  req,\n  showHiddenFields,\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      draft: draft === undefined ? false : draft,\n      lexicalNodes: data?.root?.children,\n      overrideAccess: overrideAccess === undefined ? false : overrideAccess,\n      parent: data?.root,\n      req,\n      showHiddenFields: showHiddenFields === undefined ? false : showHiddenFields,\n    })\n  }\n  return ''\n}\n\nexport async function convertLexicalNodesToHTML({\n  converters,\n  draft,\n  lexicalNodes,\n  overrideAccess,\n  parent,\n  req,\n  showHiddenFields,\n}: {\n  converters: HTMLConverter[]\n  draft: boolean\n  lexicalNodes: SerializedLexicalNode[]\n  overrideAccess: boolean\n  parent: SerializedLexicalNodeWithParent\n  /**\n   * When the converter is called, req CAN be passed in depending on where it's run.\n   */\n  req: PayloadRequest | null\n  showHiddenFields: boolean\n}): Promise<string> {\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n\n  const htmlArray = await Promise.all(\n    lexicalNodes.map(async (node, i) => {\n      const converterForNode = converters.find((converter) =>\n        converter.nodeTypes.includes(node.type),\n      )\n      try {\n        if (!converterForNode) {\n          if (unknownConverter) {\n            return await unknownConverter.converter({\n              childIndex: i,\n              converters,\n              draft,\n              node,\n              overrideAccess,\n              parent,\n              req,\n              showHiddenFields,\n            })\n          }\n          return '<span>unknown node</span>'\n        }\n        return await converterForNode.converter({\n          childIndex: i,\n          converters,\n          draft,\n          node,\n          overrideAccess,\n          parent,\n          req,\n          showHiddenFields,\n        })\n      } catch (error) {\n        console.error('Error converting lexical node to HTML:', error, 'node:', node)\n        return ''\n      }\n    }),\n  )\n\n  return htmlArray.join('') || ''\n}\n"],"names":["createLocalReq","convertLexicalToHTML","converters","data","draft","overrideAccess","payload","req","showHiddenFields","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;AAuCxC,OAAO,eAAeC,qBAAqB,EACzCC,UAAU,EACVC,IAAI,EACJC,KAAK,EACLC,cAAc,EACdC,OAAO,EACPC,GAAG,EACHC,gBAAgB,EACS;IACzB,IAAIL,MAAMM,MAAMC,UAAUC,QAAQ;QAChC,IAAIJ,QAAQK,aAAaN,SAAS;YAChCC,MAAM,MAAMP,eAAe,CAAC,GAAGM;QACjC;QAEA,OAAO,MAAMO,0BAA0B;YACrCX;YACAE,OAAOA,UAAUQ,YAAY,QAAQR;YACrCU,cAAcX,MAAMM,MAAMC;YAC1BL,gBAAgBA,mBAAmBO,YAAY,QAAQP;YACvDU,QAAQZ,MAAMM;YACdF;YACAC,kBAAkBA,qBAAqBI,YAAY,QAAQJ;QAC7D;IACF;IACA,OAAO;AACT;AAEA,OAAO,eAAeK,0BAA0B,EAC9CX,UAAU,EACVE,KAAK,EACLU,YAAY,EACZT,cAAc,EACdU,MAAM,EACNR,GAAG,EACHC,gBAAgB,EAYjB;IACC,MAAMQ,mBAAmBd,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IAErF,MAAMC,YAAY,MAAMC,QAAQC,GAAG,CACjCT,aAAaU,GAAG,CAAC,OAAOC,MAAMC;QAC5B,MAAMC,mBAAmBzB,WAAWe,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;wBACZxB;wBACAE;wBACAqB;wBACApB;wBACAU;wBACAR;wBACAC;oBACF;gBACF;gBACA,OAAO;YACT;YACA,OAAO,MAAMmB,iBAAiBT,SAAS,CAAC;gBACtCW,YAAYH;gBACZxB;gBACAE;gBACAqB;gBACApB;gBACAU;gBACAR;gBACAC;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

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

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

@@ -1 +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"}
+{"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,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACnF,SAAS,EAAE,CAAC,IAAI,EAAE;QAChB,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,CAAA;QAChC,KAAK,EAAE,OAAO,CAAA;QACd,IAAI,EAAE,CAAC,CAAA;QACP,cAAc,EAAE,OAAO,CAAA;QACvB,MAAM,EAAE,+BAA+B,CAAA;QACvC;;WAEG;QACH,GAAG,EAAE,cAAc,GAAG,IAAI,CAAA;QAC1B,gBAAgB,EAAE,OAAO,CAAA;KAC1B,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,GAAG,qBAAqB,CAAA"}

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

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

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

@@ -1,8 +1,8 @@
 import type { HTMLConverter } from './converter/types.js';
 export type HTMLConverterFeatureProps = {
     converters?: (({ defaultConverters }: {
-        defaultConverters: HTMLConverter[];
-    }) => HTMLConverter[]) | HTMLConverter[];
+        defaultConverters: HTMLConverter<any>[];
+    }) => HTMLConverter<any>[]) | HTMLConverter<any>[];
 };
-export declare const HTMLConverterFeature: import("../../types.js").FeatureProviderProviderServer<undefined, undefined, undefined>;
+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

@@ -1 +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,yFAG/B,CAAA"}
+{"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,CAAC,GAAG,CAAC,EAAE,CAAA;KAAE,KAAK,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,GAC9F,aAAa,CAAC,GAAG,CAAC,EAAE,CAAA;CACzB,CAAA;AAGD,eAAO,MAAM,oBAAoB,+HAG/B,CAAA"}

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

@@ -1 +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({\n  feature: {},\n  key: 'htmlConverter',\n})\n"],"names":["createServerFeature","HTMLConverterFeature","feature","key"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,mBAAmB,QAAQ,4CAA2C;AAQ/E,4DAA4D;AAC5D,OAAO,MAAMC,uBAAuBD,oBAAoB;IACtDE,SAAS,CAAC;IACVC,KAAK;AACP,GAAE"}
+{"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<any>[] }) => HTMLConverter<any>[])\n    | HTMLConverter<any>[]\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.map

@@ -1 +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"}
+{"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,KAyFJ,CAAA"}

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

@@ -108,7 +108,7 @@ export const lexicalHTML = (lexicalFieldName, props)=>{
         },
         hooks: {
             afterRead: [
-                async ({ collection, field, global, req, siblingData })=>{
+                async ({ collection, draft, field, global, overrideAccess, req, showHiddenFields, siblingData })=>{
                     const fields = collection ? collection.fields : global.fields;
                     const foundSiblingFields = findFieldPathAndSiblingFields(fields, [], field);
                     if (!foundSiblingFields) throw new Error(`Could not find sibling fields of current lexicalHTML field with name ${field?.name}`);
@@ -134,7 +134,10 @@ export const lexicalHTML = (lexicalFieldName, props)=>{
                     return await convertLexicalToHTML({
                         converters: finalConverters,
                         data: lexicalFieldData,
-                        req
+                        draft,
+                        overrideAccess,
+                        req,
+                        showHiddenFields
                     });
                 }
             ],

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/html/field/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { Field, FieldAffectingData, RichTextField } from 'payload'\n\nimport type { SanitizedServerEditorConfig } from '../../../../lexical/config/types.js'\nimport type { AdapterProps, LexicalRichTextAdapter } from '../../../../types.js'\nimport type { HTMLConverter } from '../converter/types.js'\nimport type { HTMLConverterFeatureProps } from '../feature.server.js'\n\nimport { defaultHTMLConverters } from '../converter/defaultConverters.js'\nimport { convertLexicalToHTML } from '../converter/index.js'\n\ntype Props = {\n  /**\n   * Whether the lexicalHTML field should be hidden in the admin panel\n   *\n   * @default true\n   */\n  hidden?: boolean\n  name: string\n  /**\n   * Whether the HTML should be stored in the database\n   *\n   * @default false\n   */\n  storeInDB?: boolean\n}\n\n/**\n * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.\n *\n * @param editorConfig\n */\nexport const consolidateHTMLConverters = ({\n  editorConfig,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n}): HTMLConverter[] => {\n  const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter')\n  const htmlConverterFeatureProps: HTMLConverterFeatureProps =\n    htmlConverterFeature?.sanitizedServerFeatureProps\n\n  const defaultConvertersWithConvertersFromFeatures = [...defaultHTMLConverters]\n\n  for (const converter of editorConfig.features.converters.html) {\n    defaultConvertersWithConvertersFromFeatures.push(converter)\n  }\n\n  const finalConverters =\n    htmlConverterFeatureProps?.converters &&\n    typeof htmlConverterFeatureProps?.converters === 'function'\n      ? htmlConverterFeatureProps.converters({\n          defaultConverters: defaultConvertersWithConvertersFromFeatures,\n        })\n      : (htmlConverterFeatureProps?.converters as HTMLConverter[]) ||\n        defaultConvertersWithConvertersFromFeatures\n\n  // filter converters by nodeTypes. The last converter in the list wins. If there are multiple converters for the same nodeType, the last one will be used and the node types will be removed from\n  // previous converters. If previous converters do not have any nodeTypes left, they will be removed from the list.\n  // This guarantees that user-added converters which are added after the default ones will always have precedence\n  const foundNodeTypes: string[] = []\n  const filteredConverters: HTMLConverter[] = []\n  for (const converter of finalConverters.reverse()) {\n    if (!converter.nodeTypes?.length) {\n      continue\n    }\n    const newConverter: HTMLConverter = {\n      converter: converter.converter,\n      nodeTypes: [...converter.nodeTypes],\n    }\n    newConverter.nodeTypes = newConverter.nodeTypes.filter((nodeType) => {\n      if (foundNodeTypes.includes(nodeType)) {\n        return false\n      }\n      foundNodeTypes.push(nodeType)\n      return true\n    })\n\n    if (newConverter.nodeTypes.length) {\n      filteredConverters.push(newConverter)\n    }\n  }\n\n  return filteredConverters\n}\n\n// find the path of this field, as well as its sibling fields, by looking for this `field` in fields and traversing it recursively\nfunction findFieldPathAndSiblingFields(\n  fields: Field[],\n  path: string[],\n  field: FieldAffectingData,\n): {\n  path: string[]\n  siblingFields: Field[]\n} {\n  for (const curField of fields) {\n    if (curField === field) {\n      return {\n        path: [...path, curField.name],\n        siblingFields: fields,\n      }\n    }\n\n    if ('fields' in curField) {\n      const result = findFieldPathAndSiblingFields(\n        curField.fields,\n        'name' in curField ? [...path, curField.name] : [...path],\n        field,\n      )\n      if (result) {\n        return result\n      }\n    } else if ('tabs' in curField) {\n      for (const tab of curField.tabs) {\n        const result = findFieldPathAndSiblingFields(\n          tab.fields,\n          'name' in tab ? [...path, tab.name] : [...path],\n          field,\n        )\n        if (result) {\n          return result\n        }\n      }\n    } else if ('blocks' in curField) {\n      for (const block of curField.blocks) {\n        if (block?.fields?.length) {\n          const result = findFieldPathAndSiblingFields(\n            block.fields,\n            [...path, curField.name, block.slug],\n            field,\n          )\n          if (result) {\n            return result\n          }\n        }\n      }\n    }\n  }\n\n  return null\n}\n\nexport const lexicalHTML: (\n  /**\n   * A string which matches the lexical field name you want to convert to HTML.\n   *\n   * This has to be a SIBLING field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.\n   **/\n  lexicalFieldName: string,\n  props: Props,\n) => Field = (lexicalFieldName, props) => {\n  const { name = 'lexicalHTML', hidden = true, storeInDB = false } = props\n  return {\n    name,\n    type: 'code',\n    admin: {\n      editorOptions: {\n        language: 'html',\n      },\n      hidden,\n    },\n    hooks: {\n      afterRead: [\n        async ({ collection, field, global, req, siblingData }) => {\n          const fields = collection ? collection.fields : global.fields\n\n          const foundSiblingFields = findFieldPathAndSiblingFields(fields, [], field)\n\n          if (!foundSiblingFields)\n            throw new Error(\n              `Could not find sibling fields of current lexicalHTML field with name ${field?.name}`,\n            )\n\n          const { siblingFields } = foundSiblingFields\n          const lexicalField: RichTextField<SerializedEditorState, AdapterProps> =\n            siblingFields.find(\n              (field) => 'name' in field && field.name === lexicalFieldName,\n            ) as RichTextField<SerializedEditorState, AdapterProps>\n\n          const lexicalFieldData: SerializedEditorState = siblingData[lexicalFieldName]\n\n          if (!lexicalFieldData) {\n            return ''\n          }\n\n          if (!lexicalField) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the referenced lexical field was not found',\n            )\n          }\n\n          const config = (lexicalField?.editor as LexicalRichTextAdapter)?.editorConfig\n\n          if (!config) {\n            throw new Error(\n              'The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.',\n            )\n          }\n\n          if (!config?.resolvedFeatureMap?.has('htmlConverter')) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature',\n            )\n          }\n\n          const finalConverters = consolidateHTMLConverters({\n            editorConfig: config,\n          })\n\n          return await convertLexicalToHTML({\n            converters: finalConverters,\n            data: lexicalFieldData,\n            req,\n          })\n        },\n      ],\n      beforeChange: [\n        ({ siblingData, value }) => {\n          if (storeInDB) {\n            return value\n          }\n          delete siblingData[name]\n          return null\n        },\n      ],\n    },\n  }\n}\n"],"names":["defaultHTMLConverters","convertLexicalToHTML","consolidateHTMLConverters","editorConfig","htmlConverterFeature","resolvedFeatureMap","get","htmlConverterFeatureProps","sanitizedServerFeatureProps","defaultConvertersWithConvertersFromFeatures","converter","features","converters","html","push","finalConverters","defaultConverters","foundNodeTypes","filteredConverters","reverse","nodeTypes","length","newConverter","filter","nodeType","includes","findFieldPathAndSiblingFields","fields","path","field","curField","name","siblingFields","result","tab","tabs","block","blocks","slug","lexicalHTML","lexicalFieldName","props","hidden","storeInDB","type","admin","editorOptions","language","hooks","afterRead","collection","global","req","siblingData","foundSiblingFields","Error","lexicalField","find","lexicalFieldData","config","editor","has","data","beforeChange","value"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../../src/features/converters/html/field/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { Field, FieldAffectingData, RichTextField } from 'payload'\n\nimport type { SanitizedServerEditorConfig } from '../../../../lexical/config/types.js'\nimport type { AdapterProps, LexicalRichTextAdapter } from '../../../../types.js'\nimport type { HTMLConverter } from '../converter/types.js'\nimport type { HTMLConverterFeatureProps } from '../feature.server.js'\n\nimport { defaultHTMLConverters } from '../converter/defaultConverters.js'\nimport { convertLexicalToHTML } from '../converter/index.js'\n\ntype Props = {\n  /**\n   * Whether the lexicalHTML field should be hidden in the admin panel\n   *\n   * @default true\n   */\n  hidden?: boolean\n  name: string\n  /**\n   * Whether the HTML should be stored in the database\n   *\n   * @default false\n   */\n  storeInDB?: boolean\n}\n\n/**\n * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.\n *\n * @param editorConfig\n */\nexport const consolidateHTMLConverters = ({\n  editorConfig,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n}): HTMLConverter[] => {\n  const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter')\n  const htmlConverterFeatureProps: HTMLConverterFeatureProps =\n    htmlConverterFeature?.sanitizedServerFeatureProps\n\n  const defaultConvertersWithConvertersFromFeatures = [...defaultHTMLConverters]\n\n  for (const converter of editorConfig.features.converters.html) {\n    defaultConvertersWithConvertersFromFeatures.push(converter)\n  }\n\n  const finalConverters =\n    htmlConverterFeatureProps?.converters &&\n    typeof htmlConverterFeatureProps?.converters === 'function'\n      ? htmlConverterFeatureProps.converters({\n          defaultConverters: defaultConvertersWithConvertersFromFeatures,\n        })\n      : (htmlConverterFeatureProps?.converters as HTMLConverter[]) ||\n        defaultConvertersWithConvertersFromFeatures\n\n  // filter converters by nodeTypes. The last converter in the list wins. If there are multiple converters for the same nodeType, the last one will be used and the node types will be removed from\n  // previous converters. If previous converters do not have any nodeTypes left, they will be removed from the list.\n  // This guarantees that user-added converters which are added after the default ones will always have precedence\n  const foundNodeTypes: string[] = []\n  const filteredConverters: HTMLConverter[] = []\n  for (const converter of finalConverters.reverse()) {\n    if (!converter.nodeTypes?.length) {\n      continue\n    }\n    const newConverter: HTMLConverter = {\n      converter: converter.converter,\n      nodeTypes: [...converter.nodeTypes],\n    }\n    newConverter.nodeTypes = newConverter.nodeTypes.filter((nodeType) => {\n      if (foundNodeTypes.includes(nodeType)) {\n        return false\n      }\n      foundNodeTypes.push(nodeType)\n      return true\n    })\n\n    if (newConverter.nodeTypes.length) {\n      filteredConverters.push(newConverter)\n    }\n  }\n\n  return filteredConverters\n}\n\n// find the path of this field, as well as its sibling fields, by looking for this `field` in fields and traversing it recursively\nfunction findFieldPathAndSiblingFields(\n  fields: Field[],\n  path: string[],\n  field: FieldAffectingData,\n): {\n  path: string[]\n  siblingFields: Field[]\n} {\n  for (const curField of fields) {\n    if (curField === field) {\n      return {\n        path: [...path, curField.name],\n        siblingFields: fields,\n      }\n    }\n\n    if ('fields' in curField) {\n      const result = findFieldPathAndSiblingFields(\n        curField.fields,\n        'name' in curField ? [...path, curField.name] : [...path],\n        field,\n      )\n      if (result) {\n        return result\n      }\n    } else if ('tabs' in curField) {\n      for (const tab of curField.tabs) {\n        const result = findFieldPathAndSiblingFields(\n          tab.fields,\n          'name' in tab ? [...path, tab.name] : [...path],\n          field,\n        )\n        if (result) {\n          return result\n        }\n      }\n    } else if ('blocks' in curField) {\n      for (const block of curField.blocks) {\n        if (block?.fields?.length) {\n          const result = findFieldPathAndSiblingFields(\n            block.fields,\n            [...path, curField.name, block.slug],\n            field,\n          )\n          if (result) {\n            return result\n          }\n        }\n      }\n    }\n  }\n\n  return null\n}\n\nexport const lexicalHTML: (\n  /**\n   * A string which matches the lexical field name you want to convert to HTML.\n   *\n   * This has to be a SIBLING field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.\n   **/\n  lexicalFieldName: string,\n  props: Props,\n) => Field = (lexicalFieldName, props) => {\n  const { name = 'lexicalHTML', hidden = true, storeInDB = false } = props\n  return {\n    name,\n    type: 'code',\n    admin: {\n      editorOptions: {\n        language: 'html',\n      },\n      hidden,\n    },\n    hooks: {\n      afterRead: [\n        async ({\n          collection,\n          draft,\n          field,\n          global,\n          overrideAccess,\n          req,\n          showHiddenFields,\n          siblingData,\n        }) => {\n          const fields = collection ? collection.fields : global.fields\n\n          const foundSiblingFields = findFieldPathAndSiblingFields(fields, [], field)\n\n          if (!foundSiblingFields)\n            throw new Error(\n              `Could not find sibling fields of current lexicalHTML field with name ${field?.name}`,\n            )\n\n          const { siblingFields } = foundSiblingFields\n          const lexicalField: RichTextField<SerializedEditorState, AdapterProps> =\n            siblingFields.find(\n              (field) => 'name' in field && field.name === lexicalFieldName,\n            ) as RichTextField<SerializedEditorState, AdapterProps>\n\n          const lexicalFieldData: SerializedEditorState = siblingData[lexicalFieldName]\n\n          if (!lexicalFieldData) {\n            return ''\n          }\n\n          if (!lexicalField) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the referenced lexical field was not found',\n            )\n          }\n\n          const config = (lexicalField?.editor as LexicalRichTextAdapter)?.editorConfig\n\n          if (!config) {\n            throw new Error(\n              'The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.',\n            )\n          }\n\n          if (!config?.resolvedFeatureMap?.has('htmlConverter')) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature',\n            )\n          }\n\n          const finalConverters = consolidateHTMLConverters({\n            editorConfig: config,\n          })\n\n          return await convertLexicalToHTML({\n            converters: finalConverters,\n            data: lexicalFieldData,\n            draft,\n            overrideAccess,\n            req,\n            showHiddenFields,\n          })\n        },\n      ],\n      beforeChange: [\n        ({ siblingData, value }) => {\n          if (storeInDB) {\n            return value\n          }\n          delete siblingData[name]\n          return null\n        },\n      ],\n    },\n  }\n}\n"],"names":["defaultHTMLConverters","convertLexicalToHTML","consolidateHTMLConverters","editorConfig","htmlConverterFeature","resolvedFeatureMap","get","htmlConverterFeatureProps","sanitizedServerFeatureProps","defaultConvertersWithConvertersFromFeatures","converter","features","converters","html","push","finalConverters","defaultConverters","foundNodeTypes","filteredConverters","reverse","nodeTypes","length","newConverter","filter","nodeType","includes","findFieldPathAndSiblingFields","fields","path","field","curField","name","siblingFields","result","tab","tabs","block","blocks","slug","lexicalHTML","lexicalFieldName","props","hidden","storeInDB","type","admin","editorOptions","language","hooks","afterRead","collection","draft","global","overrideAccess","req","showHiddenFields","siblingData","foundSiblingFields","Error","lexicalField","find","lexicalFieldData","config","editor","has","data","beforeChange","value"],"mappings":"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"}

package/dist/features/createClientComponent.d.ts

@@ -1,4 +1,5 @@
-import type { FeatureProviderProviderClient, ServerFeature } from './types.js';
+import type { FeatureProviderProviderClient } from './typesClient.js';
+import type { ServerFeature } from './typesServer.js';
 /**
  * Utility function to create a client component for the client feature
  */

package/dist/features/createClientComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createClientComponent.d.ts","sourceRoot":"","sources":["../../src/features/createClientComponent.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAI9E;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,kBAAkB,iBACvC,6BAA6B,CAAC,kBAAkB,CAAC,KAC/D,aAAa,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC,eAAe,CAK5D,CAAA"}
+{"version":3,"file":"createClientComponent.d.ts","sourceRoot":"","sources":["../../src/features/createClientComponent.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAIrD;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,kBAAkB,iBACvC,6BAA6B,CAAC,kBAAkB,CAAC,KAC/D,aAAa,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC,eAAe,CAK5D,CAAA"}

package/dist/features/createClientComponent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/features/createClientComponent.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient, ServerFeature } from './types.js'\n\nimport { useLexicalFeature } from '../utilities/useLexicalFeature.js'\n\n/**\n * Utility function to create a client component for the client feature\n */\nexport const createClientComponent = <ClientFeatureProps,>(\n  clientFeature: FeatureProviderProviderClient<ClientFeatureProps>,\n): ServerFeature<unknown, ClientFeatureProps>['ClientFeature'] => {\n  return (props) => {\n    useLexicalFeature(props.featureKey, clientFeature(props))\n    return null\n  }\n}\n"],"names":["useLexicalFeature","createClientComponent","clientFeature","props","featureKey"],"rangeMappings":";;;;;;;;;","mappings":"AAAA;AAIA,SAASA,iBAAiB,QAAQ,oCAAmC;AAErE;;CAEC,GACD,OAAO,MAAMC,wBAAwB,CACnCC;IAEA,OAAO,CAACC;QACNH,kBAAkBG,MAAMC,UAAU,EAAEF,cAAcC;QAClD,OAAO;IACT;AACF,EAAC"}
+{"version":3,"sources":["../../src/features/createClientComponent.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from './typesClient.js'\nimport type { ServerFeature } from './typesServer.js'\n\nimport { useLexicalFeature } from '../utilities/useLexicalFeature.js'\n\n/**\n * Utility function to create a client component for the client feature\n */\nexport const createClientComponent = <ClientFeatureProps,>(\n  clientFeature: FeatureProviderProviderClient<ClientFeatureProps>,\n): ServerFeature<unknown, ClientFeatureProps>['ClientFeature'] => {\n  return (props) => {\n    useLexicalFeature(props.featureKey, clientFeature(props))\n    return null\n  }\n}\n"],"names":["useLexicalFeature","createClientComponent","clientFeature","props","featureKey"],"mappings":"AAAA;AAKA,SAASA,iBAAiB,QAAQ,oCAAmC;AAErE;;CAEC,GACD,OAAO,MAAMC,wBAAwB,CACnCC;IAEA,OAAO,CAACC;QACNH,kBAAkBG,MAAMC,UAAU,EAAEF,cAAcC;QAClD,OAAO;IACT;AACF,EAAC"}