@payloadcms/richtext-lexical 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/field/features/Blocks/afterReadPromise.d.ts

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

package/dist/field/features/Blocks/afterReadPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"afterReadPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Blocks/afterReadPromise.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,GAAG,CAAA;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAI7D,eAAO,MAAM,wBAAwB,UAC5B,kBAAkB,KACxB,iBAAiB,mBAAmB,CAgDtC,CAAA"}

package/dist/field/features/Blocks/afterReadPromise.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "blockAfterReadPromiseHOC", {
+    enumerable: true,
+    get: function() {
+        return blockAfterReadPromiseHOC;
+    }
+});
+const _config = require("payload/config");
+const _recurseNestedFields = require("../../../populate/recurseNestedFields");
+const blockAfterReadPromiseHOC = (props)=>{
+    const blockAfterReadPromise = ({ afterReadPromises, currentDepth, depth, field, node, overrideAccess, req, showHiddenFields })=>{
+        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) || [];
+        props.blocks = props.blocks.map((block)=>{
+            const unsanitizedBlock = {
+                ...block
+            };
+            unsanitizedBlock.fields = (0, _config.sanitizeFields)({
+                config: payloadConfig,
+                fields: block.fields,
+                validRelationships
+            });
+            return unsanitizedBlock;
+        });
+        if (Array.isArray(props.blocks)) {
+            props.blocks.forEach((block)=>{
+                if (block?.fields) {
+                    (0, _recurseNestedFields.recurseNestedFields)({
+                        afterReadPromises,
+                        currentDepth,
+                        data: node.fields.data || {},
+                        depth,
+                        fields: block.fields,
+                        overrideAccess,
+                        promises,
+                        req,
+                        showHiddenFields
+                    });
+                }
+            });
+        }
+        return promises;
+    };
+    return blockAfterReadPromise;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Blocks/component/BlockContent.d.ts

@@ -0,0 +1,14 @@
+import type { Block } from 'payload/types';
+import React from 'react';
+import type { FieldProps } from '../../../../types';
+import type { BlockFields } from '../nodes/BlocksNode';
+type Props = {
+    baseClass: string;
+    block: Block;
+    field: FieldProps;
+    fields: BlockFields;
+    nodeKey: string;
+};
+export declare const BlockContent: React.FC<Props>;
+export {};
+//# sourceMappingURL=BlockContent.d.ts.map

package/dist/field/features/Blocks/component/BlockContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockContent.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Blocks/component/BlockContent.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAQ,MAAM,eAAe,CAAA;AAShD,OAAO,KAAsB,MAAM,OAAO,CAAA;AAG1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAa,MAAM,qBAAqB,CAAA;AAIjE,KAAK,KAAK,GAAG;IACX,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,KAAK,CAAA;IACZ,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,WAAW,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CA+GxC,CAAA"}

package/dist/field/features/Blocks/component/BlockContent.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BlockContent", {
+    enumerable: true,
+    get: function() {
+        return BlockContent;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _lexical = require("lexical");
+const _components = require("payload/components");
+const _elements = require("payload/components/elements");
+const _Blocks = require("payload/components/fields/Blocks");
+const _forms = require("payload/components/forms");
+const _utilities = require("payload/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _FormSavePlugin = require("./FormSavePlugin");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const BlockContent = (props)=>{
+    const { baseClass, block, field, fields, nodeKey } = props;
+    const { i18n } = (0, _reacti18next.useTranslation)();
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [collapsed, setCollapsed] = _react.default.useState(fields.collapsed);
+    const hasSubmitted = (0, _forms.useFormSubmitted)();
+    const childErrorPathsCount = 0 // TODO row.childErrorPaths?.size
+    ;
+    const fieldHasErrors = hasSubmitted && childErrorPathsCount > 0;
+    const classNames = [
+        `${baseClass}__row`,
+        fieldHasErrors ? `${baseClass}__row--has-errors` : `${baseClass}__row--no-errors`
+    ].filter(Boolean).join(' ');
+    const path = '';
+    const onFormChange = (0, _react.useCallback)(({ formData })=>{
+        editor.update(()=>{
+            const node = (0, _lexical.$getNodeByKey)(nodeKey);
+            if (node) {
+                node.setFields({
+                    collapsed: collapsed,
+                    data: formData
+                });
+            }
+        });
+    }, [
+        editor,
+        nodeKey,
+        collapsed
+    ]);
+    const onCollapsedChange = (0, _react.useCallback)(()=>{
+        editor.update(()=>{
+            const node = (0, _lexical.$getNodeByKey)(nodeKey);
+            if (node) {
+                node.setFields({
+                    ...node.getFields(),
+                    collapsed: collapsed
+                });
+            }
+        });
+    }, [
+        editor,
+        nodeKey,
+        collapsed
+    ]);
+    const removeBlock = (0, _react.useCallback)(()=>{
+        editor.update(()=>{
+            (0, _lexical.$getNodeByKey)(nodeKey).remove();
+        });
+    }, [
+        editor,
+        nodeKey
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement(_elements.Collapsible, {
+        className: classNames,
+        collapsed: collapsed,
+        collapsibleStyle: false ? 'error' : 'default',
+        header: /*#__PURE__*/ _react.default.createElement("div", {
+            className: `${baseClass}__block-header`
+        }, /*#__PURE__*/ _react.default.createElement("div", null, /*#__PURE__*/ _react.default.createElement(_components.Pill, {
+            className: `${baseClass}__block-pill ${baseClass}__block-pill-${fields?.data?.blockType}`,
+            pillStyle: "white"
+        }, (0, _utilities.getTranslation)(block.labels.singular, i18n)), /*#__PURE__*/ _react.default.createElement(_Blocks.SectionTitle, {
+            path: `${path}blockName`,
+            readOnly: field?.admin?.readOnly
+        }), fieldHasErrors && /*#__PURE__*/ _react.default.createElement(_components.ErrorPill, {
+            count: childErrorPathsCount,
+            withMessage: true
+        })), /*#__PURE__*/ _react.default.createElement(_components.Button, {
+            buttonStyle: "icon-label",
+            className: `${baseClass}__removeButton`,
+            disabled: field?.admin?.readOnly,
+            icon: "x",
+            onClick: (e)=>{
+                e.preventDefault();
+                removeBlock();
+            },
+            round: true,
+            tooltip: "Remove Block"
+        })),
+        key: 0,
+        onToggle: (collapsed)=>{
+            setCollapsed(collapsed);
+            onCollapsedChange();
+        }
+    }, /*#__PURE__*/ _react.default.createElement(_forms.RenderFields, {
+        className: `${baseClass}__fields`,
+        fieldSchema: block.fields.map((field)=>({
+                ...field,
+                path: (0, _forms.createNestedFieldPath)(null, field)
+            })),
+        fieldTypes: field.fieldTypes,
+        margins: "small",
+        permissions: field.permissions?.blocks?.[fields?.data?.blockType]?.fields,
+        readOnly: field.admin.readOnly
+    })), /*#__PURE__*/ _react.default.createElement(_FormSavePlugin.FormSavePlugin, {
+        fieldSchema: block.fields.map((field)=>({
+                ...field,
+                path: (0, _forms.createNestedFieldPath)(null, field)
+            })),
+        onChange: onFormChange
+    }));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/Blocks/component/BlockContent.tsx"],"sourcesContent":["import type { Block, Data } from 'payload/types'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { $getNodeByKey } from 'lexical'\nimport { Button, ErrorPill, Pill } from 'payload/components'\nimport { Collapsible } from 'payload/components/elements'\nimport { SectionTitle } from 'payload/components/fields/Blocks'\nimport { RenderFields, createNestedFieldPath, useFormSubmitted } from 'payload/components/forms'\nimport { getTranslation } from 'payload/utilities'\nimport React, { useCallback } from 'react'\nimport { useTranslation } from 'react-i18next'\n\nimport type { FieldProps } from '../../../../types'\nimport type { BlockFields, BlockNode } from '../nodes/BlocksNode'\n\nimport { FormSavePlugin } from './FormSavePlugin'\n\ntype Props = {\n  baseClass: string\n  block: Block\n  field: FieldProps\n  fields: BlockFields\n  nodeKey: string\n}\n\nexport const BlockContent: React.FC<Props> = (props) => {\n  const { baseClass, block, field, fields, nodeKey } = props\n  const { i18n } = useTranslation()\n  const [editor] = useLexicalComposerContext()\n  const [collapsed, setCollapsed] = React.useState<boolean>(fields.collapsed)\n  const hasSubmitted = useFormSubmitted()\n  const childErrorPathsCount = 0 // TODO row.childErrorPaths?.size\n  const fieldHasErrors = hasSubmitted && childErrorPathsCount > 0\n\n  const classNames = [\n    `${baseClass}__row`,\n    fieldHasErrors ? `${baseClass}__row--has-errors` : `${baseClass}__row--no-errors`,\n  ]\n    .filter(Boolean)\n    .join(' ')\n\n  const path = '' as const\n\n  const onFormChange = useCallback(\n    ({ formData }: { formData: Data }) => {\n      editor.update(() => {\n        const node: BlockNode = $getNodeByKey(nodeKey)\n        if (node) {\n          node.setFields({\n            collapsed: collapsed,\n            data: formData as any,\n          })\n        }\n      })\n    },\n    [editor, nodeKey, collapsed],\n  )\n\n  const onCollapsedChange = useCallback(() => {\n    editor.update(() => {\n      const node: BlockNode = $getNodeByKey(nodeKey)\n      if (node) {\n        node.setFields({\n          ...node.getFields(),\n          collapsed: collapsed,\n        })\n      }\n    })\n  }, [editor, nodeKey, collapsed])\n\n  const removeBlock = useCallback(() => {\n    editor.update(() => {\n      $getNodeByKey(nodeKey).remove()\n    })\n  }, [editor, nodeKey])\n\n  return (\n    <React.Fragment>\n      <Collapsible\n        className={classNames}\n        collapsed={collapsed}\n        collapsibleStyle={false ? 'error' : 'default'}\n        header={\n          <div className={`${baseClass}__block-header`}>\n            <div>\n              <Pill\n                className={`${baseClass}__block-pill ${baseClass}__block-pill-${fields?.data?.blockType}`}\n                pillStyle=\"white\"\n              >\n                {getTranslation(block.labels.singular, i18n)}\n              </Pill>\n              <SectionTitle path={`${path}blockName`} readOnly={field?.admin?.readOnly} />\n              {fieldHasErrors && <ErrorPill count={childErrorPathsCount} withMessage />}\n            </div>\n            <Button\n              buttonStyle=\"icon-label\"\n              className={`${baseClass}__removeButton`}\n              disabled={field?.admin?.readOnly}\n              icon=\"x\"\n              onClick={(e) => {\n                e.preventDefault()\n                removeBlock()\n              }}\n              round\n              tooltip=\"Remove Block\"\n            />\n          </div>\n        }\n        key={0}\n        onToggle={(collapsed) => {\n          setCollapsed(collapsed)\n          onCollapsedChange()\n        }}\n      >\n        <RenderFields\n          className={`${baseClass}__fields`}\n          fieldSchema={block.fields.map((field) => ({\n            ...field,\n            path: createNestedFieldPath(null, field),\n          }))}\n          fieldTypes={field.fieldTypes}\n          margins=\"small\"\n          permissions={field.permissions?.blocks?.[fields?.data?.blockType]?.fields}\n          readOnly={field.admin.readOnly}\n        />\n      </Collapsible>\n\n      <FormSavePlugin\n        fieldSchema={block.fields.map((field) => ({\n          ...field,\n          path: createNestedFieldPath(null, field),\n        }))}\n        onChange={onFormChange}\n      />\n    </React.Fragment>\n  )\n}\n"],"names":["BlockContent","props","baseClass","block","field","fields","nodeKey","i18n","useTranslation","editor","useLexicalComposerContext","collapsed","setCollapsed","React","useState","hasSubmitted","useFormSubmitted","childErrorPathsCount","fieldHasErrors","classNames","filter","Boolean","join","path","onFormChange","useCallback","formData","update","node","$getNodeByKey","setFields","data","onCollapsedChange","getFields","removeBlock","remove","Fragment","Collapsible","className","collapsibleStyle","header","div","Pill","blockType","pillStyle","getTranslation","labels","singular","SectionTitle","readOnly","admin","ErrorPill","count","withMessage","Button","buttonStyle","disabled","icon","onClick","e","preventDefault","round","tooltip","key","onToggle","RenderFields","fieldSchema","map","createNestedFieldPath","fieldTypes","margins","permissions","blocks","FormSavePlugin","onChange"],"mappings":"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"}

package/dist/field/features/Blocks/component/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Blocks/component/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAS/D,OAAO,KAA+B,MAAM,OAAO,CAAA;AAInD,OAAO,EAAoB,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAexE,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,WAAW,CAAA;IACnB,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAiH1C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Blocks/component/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,OAAO,KAAkB,MAAM,OAAO,CAAA;AAEtC,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAYtD,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,WAAW,CAAA;IACnB,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAsC1C,CAAA"}

package/dist/field/features/Blocks/component/index.js

@@ -8,17 +8,12 @@ Object.defineProperty(exports, "BlockComponent", {
         return BlockComponent;
     }
 });
-const _lexical = require("lexical");
-const _elements = require("payload/components/elements");
 const _forms = require("payload/components/forms");
 const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
-const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
-const _components = require("payload/components");
-const _Blocks = require("payload/components/fields/Blocks");
-const _utilities = require("payload/utilities");
-const _reacti18next = require("react-i18next");
+const _utilities = require("payload/components/utilities");
+const _config = require("payload/config");
 const _EditorConfigProvider = require("../../../lexical/config/EditorConfigProvider");
-const _FormSavePlugin = require("./FormSavePlugin");
+const _BlockContent = require("./BlockContent");
 require("./index.scss");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -62,115 +57,37 @@ function _interop_require_wildcard(obj, nodeInterop) {
 const baseClass = 'lexical-block';
 const BlockComponent = (props)=>{
     const { children, className, fields, format, nodeKey } = props;
-    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const payloadConfig = (0, _utilities.useConfig)();
     const { editorConfig, field } = (0, _EditorConfigProvider.useEditorConfigContext)();
-    const { i18n } = (0, _reacti18next.useTranslation)();
-    const [collapsed, setCollapsed] = _react.default.useState(fields.collapsed);
-    const [blockName, setBlockName] = _react.default.useState(fields.blockName);
-    const path = `${field.path}.${0}`;
-    const block = (editorConfig?.resolvedFeatureMap?.get('blocks')?.props)?.blocks?.find((block)=>block.slug === fields?.type);
-    const onFormChange = (0, _react.useCallback)(({ formData })=>{
-        editor.update(()=>{
-            const node = (0, _lexical.$getNodeByKey)(nodeKey);
-            if (node) {
-                node.setFields({
-                    blockName: blockName,
-                    collapsed: collapsed,
-                    data: formData,
-                    type: block.slug
-                });
-            }
-        });
-    }, [
-        block?.slug,
-        editor,
-        nodeKey,
-        collapsed,
-        blockName
-    ]);
-    const onCollapsedOrBlockNameChange = (0, _react.useCallback)(()=>{
-        editor.update(()=>{
-            const node = (0, _lexical.$getNodeByKey)(nodeKey);
-            if (node) {
-                node.setFields({
-                    ...node.getFields(),
-                    blockName: blockName,
-                    collapsed: collapsed
-                });
-            }
-        });
-    }, [
-        editor,
-        nodeKey,
-        collapsed,
-        blockName
-    ]);
+    const block = (editorConfig?.resolvedFeatureMap?.get('blocks')?.props)?.blocks?.find((block)=>block.slug === fields?.data?.blockType);
+    // Sanitize block's fields here. This is done here and not in the feature, because the payload config is available here
+    const validRelationships = payloadConfig.collections.map((c)=>c.slug) || [];
+    block.fields = (0, _config.sanitizeFields)({
+        config: payloadConfig,
+        fields: block.fields,
+        validRelationships
+    });
     const initialDataRef = _react.default.useRef((0, _forms.buildInitialState)(fields.data || {})) // Store initial value in a ref, so it doesn't change on re-render and only gets initialized once
     ;
     // Memoized Form JSX
     const formContent = (0, _react.useMemo)(()=>{
         return block && /*#__PURE__*/ _react.default.createElement(_forms.Form, {
             initialState: initialDataRef?.current
-        }, /*#__PURE__*/ _react.default.createElement("div", {
-            id: `row-${0}`,
-            key: `$row-${0}`
-        }, /*#__PURE__*/ _react.default.createElement(_elements.Collapsible, {
-            className: "",
-            collapsed: collapsed,
-            collapsibleStyle: false ? 'error' : 'default',
-            header: /*#__PURE__*/ _react.default.createElement("div", {
-                className: `${baseClass}__block-header`
-            }, /*#__PURE__*/ _react.default.createElement(_components.Pill, {
-                className: `${baseClass}__block-pill ${baseClass}__block-pill-${fields.type}`,
-                pillStyle: "white"
-            }, (0, _utilities.getTranslation)(block.labels.singular, i18n)), /*#__PURE__*/ _react.default.createElement(_Blocks.SectionTitle, {
-                customOnChange: (e)=>{
-                    e.stopPropagation();
-                    e.preventDefault();
-                    setBlockName(e.target.value);
-                    onCollapsedOrBlockNameChange();
-                },
-                customValue: blockName,
-                path: `${path}.blockName`,
-                readOnly: field?.admin?.readOnly
-            }), false && /*#__PURE__*/ _react.default.createElement(_components.ErrorPill, {
-                count: 0,
-                withMessage: true
-            })),
-            key: 0,
-            onToggle: (collapsed)=>{
-                setCollapsed(collapsed);
-                onCollapsedOrBlockNameChange();
-            }
-        }, /*#__PURE__*/ _react.default.createElement(_forms.HiddenInput, {
-            name: `${path}.id`,
-            value: 0
-        }), /*#__PURE__*/ _react.default.createElement(_forms.RenderFields, {
-            className: `${baseClass}__fields`,
-            fieldSchema: block.fields.map((field)=>({
-                    ...field,
-                    path: (0, _forms.createNestedFieldPath)(null, field)
-                })),
-            fieldTypes: field.fieldTypes,
-            margins: "small",
-            permissions: field.permissions?.blocks?.[fields?.type]?.fields,
-            readOnly: field.admin.readOnly
-        }))), /*#__PURE__*/ _react.default.createElement(_FormSavePlugin.FormSavePlugin, {
-            fieldSchema: block.fields.map((field)=>({
-                    ...field,
-                    path: (0, _forms.createNestedFieldPath)(null, field)
-                })),
-            onChange: onFormChange
+        }, /*#__PURE__*/ _react.default.createElement(_BlockContent.BlockContent, {
+            baseClass: baseClass,
+            block: block,
+            field: field,
+            fields: fields,
+            nodeKey: nodeKey
         }));
     }, [
         block,
-        onFormChange,
-        field.fieldTypes,
-        field.admin.readOnly
+        field,
+        nodeKey
     ]);
     return /*#__PURE__*/ _react.default.createElement("div", {
         className: baseClass
     }, formContent);
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/features/Blocks/component/index.tsx"],"sourcesContent":["import { $getNodeByKey, type ElementFormatType } from 'lexical'\nimport { Collapsible } from 'payload/components/elements'\nimport {\n  Form,\n  HiddenInput,\n  RenderFields,\n  buildInitialState,\n  createNestedFieldPath,\n} from 'payload/components/forms'\nimport React, { useCallback, useMemo } from 'react'\n\nimport type { BlockNode } from '../nodes/BlocksNode'\n\nimport { $createBlockNode, type BlockFields } from '../nodes/BlocksNode'\nconst baseClass = 'lexical-block'\n\nimport type { Data } from 'payload/types'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { ErrorPill, Pill } from 'payload/components'\nimport { RowActions, SectionTitle } from 'payload/components/fields/Blocks'\nimport { getTranslation } from 'payload/utilities'\nimport { useTranslation } from 'react-i18next'\n\nimport type { BlocksFeatureProps } from '..'\n\nimport { useEditorConfigContext } from '../../../lexical/config/EditorConfigProvider'\nimport { FormSavePlugin } from './FormSavePlugin'\nimport './index.scss'\n\ntype Props = {\n  children?: React.ReactNode\n  className?: string\n  fields: BlockFields\n  format?: ElementFormatType\n  nodeKey?: string\n}\n\nexport const BlockComponent: React.FC<Props> = (props) => {\n  const { children, className, fields, format, nodeKey } = props\n  const [editor] = useLexicalComposerContext()\n  const { editorConfig, field } = useEditorConfigContext()\n  const { i18n } = useTranslation()\n  const [collapsed, setCollapsed] = React.useState<boolean>(fields.collapsed)\n  const [blockName, setBlockName] = React.useState<string>(fields.blockName)\n\n  const path = `${field.path}.${0}`\n\n  const block = (\n    editorConfig?.resolvedFeatureMap?.get('blocks')?.props as BlocksFeatureProps\n  )?.blocks?.find((block) => block.slug === fields?.type)\n\n  const onFormChange = useCallback(\n    ({ formData }: { formData: Data }) => {\n      editor.update(() => {\n        const node: BlockNode = $getNodeByKey(nodeKey)\n        if (node) {\n          node.setFields({\n            blockName: blockName,\n            collapsed: collapsed,\n            data: formData,\n            type: block.slug,\n          })\n        }\n      })\n    },\n    [block?.slug, editor, nodeKey, collapsed, blockName],\n  )\n\n  const onCollapsedOrBlockNameChange = useCallback(() => {\n    editor.update(() => {\n      const node: BlockNode = $getNodeByKey(nodeKey)\n      if (node) {\n        node.setFields({\n          ...node.getFields(),\n          blockName: blockName,\n          collapsed: collapsed,\n        })\n      }\n    })\n  }, [editor, nodeKey, collapsed, blockName])\n\n  const initialDataRef = React.useRef<Data>(buildInitialState(fields.data || {})) // Store initial value in a ref, so it doesn't change on re-render and only gets initialized once\n\n  // Memoized Form JSX\n  const formContent = useMemo(() => {\n    return (\n      block && (\n        <Form initialState={initialDataRef?.current}>\n          <div id={`row-${0}`} key={`$row-${0}`}>\n            <Collapsible\n              className=\"\"\n              collapsed={collapsed}\n              collapsibleStyle={false ? 'error' : 'default'}\n              header={\n                <div className={`${baseClass}__block-header`}>\n                  <Pill\n                    className={`${baseClass}__block-pill ${baseClass}__block-pill-${fields.type}`}\n                    pillStyle=\"white\"\n                  >\n                    {getTranslation(block.labels.singular, i18n)}\n                  </Pill>\n                  <SectionTitle\n                    customOnChange={(e) => {\n                      e.stopPropagation()\n                      e.preventDefault()\n                      setBlockName(e.target.value)\n                      onCollapsedOrBlockNameChange()\n                    }}\n                    customValue={blockName}\n                    path={`${path}.blockName`}\n                    readOnly={field?.admin?.readOnly}\n                  />\n                  {false && <ErrorPill count={0} withMessage />}\n                </div>\n              }\n              key={0}\n              onToggle={(collapsed) => {\n                setCollapsed(collapsed)\n                onCollapsedOrBlockNameChange()\n              }}\n            >\n              <HiddenInput name={`${path}.id`} value={0} />\n\n              <RenderFields\n                className={`${baseClass}__fields`}\n                fieldSchema={block.fields.map((field) => ({\n                  ...field,\n                  path: createNestedFieldPath(null, field),\n                }))}\n                fieldTypes={field.fieldTypes}\n                margins=\"small\"\n                permissions={field.permissions?.blocks?.[fields?.type]?.fields}\n                readOnly={field.admin.readOnly}\n              />\n            </Collapsible>\n          </div>\n\n          <FormSavePlugin\n            fieldSchema={block.fields.map((field) => ({\n              ...field,\n              path: createNestedFieldPath(null, field),\n            }))}\n            onChange={onFormChange}\n          />\n        </Form>\n      )\n    )\n  }, [block, onFormChange, field.fieldTypes, field.admin.readOnly])\n\n  return <div className={baseClass}>{formContent}</div>\n}\n"],"names":["BlockComponent","baseClass","props","children","className","fields","format","nodeKey","editor","useLexicalComposerContext","editorConfig","field","useEditorConfigContext","i18n","useTranslation","collapsed","setCollapsed","React","useState","blockName","setBlockName","path","block","resolvedFeatureMap","get","blocks","find","slug","type","onFormChange","useCallback","formData","update","node","$getNodeByKey","setFields","data","onCollapsedOrBlockNameChange","getFields","initialDataRef","useRef","buildInitialState","formContent","useMemo","Form","initialState","current","div","id","key","Collapsible","collapsibleStyle","header","Pill","pillStyle","getTranslation","labels","singular","SectionTitle","customOnChange","e","stopPropagation","preventDefault","target","value","customValue","readOnly","admin","ErrorPill","count","withMessage","onToggle","HiddenInput","name","RenderFields","fieldSchema","map","createNestedFieldPath","fieldTypes","margins","permissions","FormSavePlugin","onChange"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Blocks/component/index.scss

@@ -8,6 +8,8 @@
     --font-body
   ); // Reset font to non-serif, body font, as the lexical editor parent uses a serif font.
 
+  margin: 0 0 1.5em;
+
   &__header {
     h3 {
       margin: 0;
@@ -61,11 +63,32 @@
     }
   }
 
+  .collapsible {
+    &__header-wrap {
+      //  Make more space for the block header (default right: is base(3)) so that the remove button aligns nicely to the right
+      right: base(1.5);
+    }
+  }
+
+  &__removeButton {
+    margin: 0;
+  }
+
   &__block-header {
-    display: inline-flex;
+    pointer-events: none;
+  }
+
+  &__block-header * {
+    pointer-events: all;
+  }
+
+  &__block-header,
+  &__block-header div {
+    display: flex;
     max-width: 100%;
     overflow: hidden;
     gap: base(0.375);
+    justify-content: space-between;
   }
 
   &__block-number {

package/dist/field/features/Blocks/drawer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Blocks/drawer/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,cAAc,EAGpB,MAAM,SAAS,CAAA;AAIhB,OAAO,KAA2C,MAAM,OAAO,CAAA;AAQ/D,OAAO,cAAc,CAAA;AAGrB,eAAO,MAAM,gCAAgC,EAAE,cAAc,CAAC;IAC5D,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAA;CACrC,CAAqD,CAAA;AAmCtD,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAwDzC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Blocks/drawer/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,cAAc,EAGpB,MAAM,SAAS,CAAA;AAIhB,OAAO,KAA2C,MAAM,OAAO,CAAA;AAQ/D,OAAO,cAAc,CAAA;AAGrB,eAAO,MAAM,gCAAgC,EAAE,cAAc,CAAC;IAC5D,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAA;CACrC,CAAqD,CAAA;AAqCtD,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAwDzC,CAAA"}

package/dist/field/features/Blocks/drawer/index.js

@@ -72,20 +72,22 @@ const INSERT_BLOCK_WITH_DRAWER_COMMAND = (0, _lexical.createCommand)('INSERT_BLO
 const insertBlock = ({ blockType, editor, replaceNodeKey })=>{
     if (!replaceNodeKey) {
         editor.dispatchCommand(_plugin.INSERT_BLOCK_COMMAND, {
-            blockName: '',
             collapsed: false,
-            data: null,
-            type: blockType
+            data: {
+                blockName: '',
+                blockType: blockType
+            }
         });
     } else {
         editor.update(()=>{
             const node = (0, _lexical.$getNodeByKey)(replaceNodeKey);
             if (node) {
                 node.replace((0, _BlocksNode.$createBlockNode)({
-                    blockName: '',
                     collapsed: false,
-                    data: null,
-                    type: blockType
+                    data: {
+                        blockName: '',
+                        blockType: blockType
+                    }
                 }));
             }
         });
@@ -137,4 +139,4 @@ const BlocksDrawerComponent = ()=>{
     });
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Blocks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Blocks/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAK1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAK/C,OAAO,cAAc,CAAA;AAIrB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,aAAa,WAAY,kBAAkB,KAAG,eA4D1D,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Blocks/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAK1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAM/C,OAAO,cAAc,CAAA;AAIrB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,aAAa,WAAY,kBAAkB,KAAG,eA2E1D,CAAA"}