@payloadcms/richtext-lexical 0.1.0-beta.0

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

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BlockComponent", {
+    enumerable: true,
+    get: function() {
+        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 _EditorConfigProvider = require("../../../lexical/config/EditorConfigProvider");
+const _FormSavePlugin = require("./FormSavePlugin");
+require("./index.scss");
+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 baseClass = 'lexical-block';
+const BlockComponent = (props)=>{
+    const { children, className, fields, format, nodeKey } = props;
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    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 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
+        }));
+    }, [
+        block,
+        onFormChange,
+        field.fieldTypes,
+        field.admin.readOnly
+    ]);
+    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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"}

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

@@ -0,0 +1,10 @@
+import { type LexicalCommand } from 'lexical';
+import React from 'react';
+import './index.scss';
+export declare const INSERT_BLOCK_WITH_DRAWER_COMMAND: LexicalCommand<{
+    replace: {
+        nodeKey: string;
+    } | false;
+}>;
+export declare const BlocksDrawerComponent: React.FC;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    INSERT_BLOCK_WITH_DRAWER_COMMAND: function() {
+        return INSERT_BLOCK_WITH_DRAWER_COMMAND;
+    },
+    BlocksDrawerComponent: function() {
+        return BlocksDrawerComponent;
+    }
+});
+const _modal = require("@faceless-ui/modal");
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _lexical = require("lexical");
+const _elements = require("payload/components/elements");
+const _Blocks = require("payload/components/fields/Blocks");
+const _utilities = require("payload/components/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _EditorConfigProvider = require("../../../lexical/config/EditorConfigProvider");
+const _BlocksNode = require("../nodes/BlocksNode");
+const _plugin = require("../plugin");
+require("./index.scss");
+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 baseClass = 'lexical-blocks-drawer';
+const INSERT_BLOCK_WITH_DRAWER_COMMAND = (0, _lexical.createCommand)('INSERT_BLOCK_WITH_DRAWER_COMMAND');
+const insertBlock = ({ blockType, editor, replaceNodeKey })=>{
+    if (!replaceNodeKey) {
+        editor.dispatchCommand(_plugin.INSERT_BLOCK_COMMAND, {
+            blockName: '',
+            collapsed: false,
+            data: null,
+            type: blockType
+        });
+    } else {
+        editor.update(()=>{
+            const node = (0, _lexical.$getNodeByKey)(replaceNodeKey);
+            if (node) {
+                node.replace((0, _BlocksNode.$createBlockNode)({
+                    blockName: '',
+                    collapsed: false,
+                    data: null,
+                    type: blockType
+                }));
+            }
+        });
+    }
+};
+const BlocksDrawerComponent = ()=>{
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const { editorConfig, uuid } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const [replaceNodeKey, setReplaceNodeKey] = (0, _react.useState)(null);
+    const editDepth = (0, _utilities.useEditDepth)();
+    const { t } = (0, _reacti18next.useTranslation)('fields');
+    const { closeModal, openModal } = (0, _modal.useModal)();
+    const labels = {
+        plural: t('blocks') || 'Blocks',
+        singular: t('block') || 'Block'
+    };
+    const addRow = (0, _react.useCallback)(async (rowIndex, blockType)=>{
+        insertBlock({
+            blockType: blockType,
+            editor,
+            replaceNodeKey
+        });
+    }, [
+        editor,
+        replaceNodeKey
+    ]);
+    const drawerSlug = (0, _elements.formatDrawerSlug)({
+        depth: editDepth,
+        slug: `lexical-rich-text-blocks-` + uuid
+    });
+    const blocks = (editorConfig?.resolvedFeatureMap?.get('blocks')?.props)?.blocks;
+    (0, _react.useEffect)(()=>{
+        return editor.registerCommand(INSERT_BLOCK_WITH_DRAWER_COMMAND, (payload)=>{
+            setReplaceNodeKey(payload?.replace ? payload?.replace.nodeKey : null);
+            openModal(drawerSlug);
+            return true;
+        }, _lexical.COMMAND_PRIORITY_EDITOR);
+    }, [
+        editor,
+        drawerSlug,
+        openModal
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_Blocks.BlocksDrawer, {
+        addRow: addRow,
+        addRowIndex: 0,
+        blocks: blocks,
+        drawerSlug: drawerSlug,
+        labels: labels
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,8 @@
+import type { Block } from 'payload/types';
+import type { FeatureProvider } from '../types';
+import './index.scss';
+export type BlocksFeatureProps = {
+    blocks: Block[];
+};
+export declare const BlocksFeature: (props?: BlocksFeatureProps) => FeatureProvider;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BlocksFeature", {
+    enumerable: true,
+    get: function() {
+        return BlocksFeature;
+    }
+});
+const _config = require("payload/config");
+const _utilities = require("payload/utilities");
+const _LexicalMenu = require("../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu");
+const _Block = require("../../lexical/ui/icons/Block");
+const _drawer = require("./drawer");
+require("./index.scss");
+const _BlocksNode = require("./nodes/BlocksNode");
+const _plugin = require("./plugin");
+const BlocksFeature = (props)=>{
+    // Sanitization taken from payload/src/fields/config/sanitize.ts
+    if (props?.blocks?.length) {
+        props.blocks = props.blocks.map((block)=>({
+                ...block,
+                fields: block.fields.concat(_config.baseBlockFields)
+            }));
+        props.blocks = props.blocks.map((block)=>{
+            const unsanitizedBlock = {
+                ...block
+            };
+            unsanitizedBlock.labels = !unsanitizedBlock.labels ? (0, _utilities.formatLabels)(unsanitizedBlock.slug) : unsanitizedBlock.labels;
+            // TODO
+            /*unsanitizedBlock.fields = sanitizeFields({
+        config,
+        fields: block.fields,
+        validRelationships,
+      })*/ return unsanitizedBlock;
+        });
+    }
+    return {
+        feature: ({ resolvedFeatures, unsanitizedEditorConfig })=>{
+            return {
+                nodes: [
+                    {
+                        node: _BlocksNode.BlockNode,
+                        type: _BlocksNode.BlockNode.getType()
+                    }
+                ],
+                plugins: [
+                    {
+                        Component: _plugin.BlocksPlugin,
+                        position: 'normal'
+                    }
+                ],
+                props: props,
+                slashMenu: {
+                    options: [
+                        {
+                            options: [
+                                new _LexicalMenu.SlashMenuOption('Block', {
+                                    Icon: _Block.BlockIcon,
+                                    keywords: [
+                                        'block',
+                                        'blocks'
+                                    ],
+                                    onSelect: ({ editor })=>{
+                                        editor.dispatchCommand(_drawer.INSERT_BLOCK_WITH_DRAWER_COMMAND, null);
+                                    }
+                                })
+                            ],
+                            title: 'Basic'
+                        }
+                    ]
+                }
+            };
+        },
+        key: 'blocks'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Blocks/nodes/BlocksNode.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+import type { DOMConversionMap, DOMExportOutput, EditorConfig, ElementFormatType, LexicalEditor, LexicalNode, NodeKey, Spread } from 'lexical';
+import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+export type BlockFields = {
+    blockName: string;
+    collapsed: boolean;
+    /** Block data */
+    data: null | unknown;
+    /** Block type. This is the slug of the block added to the Blocks Feature */
+    type: string;
+};
+export type SerializedBlockNode = Spread<{
+    fields: BlockFields;
+}, SerializedDecoratorBlockNode>;
+export declare class BlockNode extends DecoratorBlockNode {
+    __fields: BlockFields;
+    constructor({ fields, format, key, }: {
+        fields: BlockFields;
+        format?: ElementFormatType;
+        key?: NodeKey;
+    });
+    static clone(node: BlockNode): BlockNode;
+    static getType(): string;
+    static importDOM(): DOMConversionMap<HTMLDivElement> | null;
+    static importJSON(serializedNode: SerializedBlockNode): BlockNode;
+    static isInline(): false;
+    decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedBlockNode;
+    getFields(): BlockFields;
+    getId(): string;
+    getTextContent(): string;
+    setFields(fields: BlockFields): void;
+}
+export declare function $createBlockNode(fields: BlockFields): BlockNode;
+export declare function $isBlockNode(node: BlockNode | LexicalNode | null | undefined): node is BlockNode;
+//# sourceMappingURL=BlocksNode.d.ts.map

package/dist/field/features/Blocks/nodes/BlocksNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlocksNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Blocks/nodes/BlocksNode.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAA;AAC5F,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,OAAO,EACP,MAAM,EACP,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAA;AAK7E,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,OAAO,CAAA;IAClB,iBAAiB;IACjB,IAAI,EAAE,IAAI,GAAG,OAAO,CAAA;IACpB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,MAAM,CACtC;IACE,MAAM,EAAE,WAAW,CAAA;CACpB,EACD,4BAA4B,CAC7B,CAAA;AAED,qBAAa,SAAU,SAAQ,kBAAkB;IAC/C,QAAQ,EAAE,WAAW,CAAA;gBAET,EACV,MAAM,EACN,MAAM,EACN,GAAG,GACJ,EAAE;QACD,MAAM,EAAE,WAAW,CAAA;QACnB,MAAM,CAAC,EAAE,iBAAiB,CAAA;QAC1B,GAAG,CAAC,EAAE,OAAO,CAAA;KACd;IAKD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS;IAQxC,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,SAAS,IAAI,gBAAgB,CAAC,cAAc,CAAC,GAAG,IAAI;IAI3D,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,mBAAmB,GAAG,SAAS;IAMjE,MAAM,CAAC,QAAQ,IAAI,KAAK;IAGxB,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,OAAO;IAWlE,SAAS,IAAI,eAAe;IAQ5B,UAAU,IAAI,mBAAmB;IASjC,SAAS,IAAI,WAAW;IAGxB,KAAK,IAAI,MAAM;IAIf,cAAc,IAAI,MAAM;IAIxB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;CAIrC;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAI/D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,SAAS,CAEhG"}

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    BlockNode: function() {
+        return BlockNode;
+    },
+    $createBlockNode: function() {
+        return $createBlockNode;
+    },
+    $isBlockNode: function() {
+        return $isBlockNode;
+    }
+});
+const _LexicalDecoratorBlockNode = require("@lexical/react/LexicalDecoratorBlockNode");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _component = require("../component");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class BlockNode extends _LexicalDecoratorBlockNode.DecoratorBlockNode {
+    __fields;
+    constructor({ fields, format, key }){
+        super(format, key);
+        this.__fields = fields;
+    }
+    static clone(node) {
+        return new BlockNode({
+            fields: node.__fields,
+            format: node.__format,
+            key: node.__key
+        });
+    }
+    static getType() {
+        return 'block';
+    }
+    static importDOM() {
+        return {};
+    }
+    static importJSON(serializedNode) {
+        const node = $createBlockNode(serializedNode.fields);
+        node.setFormat(serializedNode.format);
+        return node;
+    }
+    static isInline() {
+        return false;
+    }
+    decorate(editor, config) {
+        return /*#__PURE__*/ _react.default.createElement(_component.BlockComponent, {
+            className: config.theme.block ?? 'LexicalEditorTheme__block',
+            fields: this.__fields,
+            format: this.__format,
+            nodeKey: this.getKey()
+        });
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        const text = document.createTextNode(this.getTextContent());
+        element.append(text);
+        return {
+            element
+        };
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            fields: this.getFields(),
+            type: this.getType(),
+            version: 1
+        };
+    }
+    getFields() {
+        return this.getLatest().__fields;
+    }
+    getId() {
+        return this.__id;
+    }
+    getTextContent() {
+        return `Block Field`;
+    }
+    setFields(fields) {
+        const writable = this.getWritable();
+        writable.__fields = fields;
+    }
+}
+function $createBlockNode(fields) {
+    return new BlockNode({
+        fields
+    });
+}
+function $isBlockNode(node) {
+    return node instanceof BlockNode;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { type LexicalCommand } from 'lexical';
+import type { BlockFields } from '../nodes/BlocksNode';
+export type InsertBlockPayload = BlockFields;
+export declare const INSERT_BLOCK_COMMAND: LexicalCommand<InsertBlockPayload>;
+export declare function BlocksPlugin(): JSX.Element | null;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Blocks/plugin/index.tsx"],"names":[],"mappings":";AAEA,OAAO,EAA2B,KAAK,cAAc,EAAiB,MAAM,SAAS,CAAA;AAGrF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAKtD,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAA;AAE5C,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,kBAAkB,CAC7B,CAAA;AAEvC,wBAAgB,YAAY,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI,CA0BjD"}