@payloadcms/richtext-lexical 0.1.0-beta.0

package/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2022 Payload CMS, LLC <info@payloadcms.com>
+Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cell/index.d.ts

@@ -0,0 +1,6 @@
+import type { SerializedEditorState } from 'lexical';
+import type { CellComponentProps, RichTextField } from 'payload/types';
+import React from 'react';
+import type { AdapterProps } from '../types';
+export declare const RichTextCell: React.FC<CellComponentProps<RichTextField<AdapterProps>, SerializedEditorState> & AdapterProps>;
+//# sourceMappingURL=index.d.ts.map

package/dist/cell/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cell/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAItE,OAAO,KAAoB,MAAM,OAAO,CAAA;AAExC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAI5C,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CACjC,kBAAkB,CAAC,aAAa,CAAC,YAAY,CAAC,EAAE,qBAAqB,CAAC,GAAG,YAAY,CAgCtF,CAAA"}

package/dist/cell/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RichTextCell", {
+    enumerable: true,
+    get: function() {
+        return RichTextCell;
+    }
+});
+const _headless = require("@lexical/headless");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _nodes = require("../field/lexical/nodes");
+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 RichTextCell = ({ data, editorConfig })=>{
+    const [preview, setPreview] = _react.default.useState('Loading...');
+    (0, _react.useEffect)(()=>{
+        if (data == null) {
+            setPreview('');
+            return;
+        }
+        // initialize headless editor
+        const headlessEditor = (0, _headless.createHeadlessEditor)({
+            namespace: editorConfig.lexical.namespace,
+            nodes: (0, _nodes.getEnabledNodes)({
+                editorConfig
+            }),
+            theme: editorConfig.lexical.theme
+        });
+        headlessEditor.setEditorState(headlessEditor.parseEditorState(data));
+        const textContent = headlessEditor.getEditorState().read(()=>{
+            return (0, _lexical.$getRoot)().getTextContent();
+        }) || '';
+        // Limit preview to 150 characters
+        if (textContent.length > 150) {
+            setPreview(textContent.slice(0, 150) + '...');
+            return;
+        }
+        setPreview(textContent);
+    }, [
+        data,
+        editorConfig
+    ]);
+    return /*#__PURE__*/ _react.default.createElement("span", null, preview);
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/Field.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { FieldProps } from '../types';
+import './index.scss';
+declare const _default: React.FC<FieldProps>;
+export default _default;
+//# sourceMappingURL=Field.d.ts.map

package/dist/field/Field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Field.d.ts","sourceRoot":"","sources":["../../src/field/Field.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAsB,MAAM,OAAO,CAAA;AAG1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAG1C,OAAO,cAAc,CAAA;;AAgGrB,wBAAsC"}

package/dist/field/Field.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _forms = require("payload/components/forms");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacterrorboundary = require("react-error-boundary");
+const _validation = require("../populate/validation");
+require("./index.scss");
+const _LexicalProvider = require("./lexical/LexicalProvider");
+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 = 'rich-text-lexical';
+const RichText = (props)=>{
+    const { name, admin: { className, condition, description, readOnly, style, width } = {
+        className,
+        condition,
+        description,
+        readOnly,
+        style,
+        width
+    }, admin, defaultValue: defaultValueFromProps, editorConfig, label, path: pathFromProps, required, validate = _validation.richTextValidate } = props;
+    const path = pathFromProps || name;
+    const memoizedValidate = (0, _react.useCallback)((value, validationOptions)=>{
+        return validate(value, {
+            ...validationOptions,
+            required
+        });
+    }, [
+        validate,
+        required
+    ]);
+    const fieldType = (0, _forms.useField)({
+        condition,
+        path,
+        validate: memoizedValidate
+    });
+    const { errorMessage, initialValue, setValue, showError, value } = fieldType;
+    const classes = [
+        baseClass,
+        'field-type',
+        className,
+        showError && 'error',
+        readOnly && `${baseClass}--read-only`
+    ].filter(Boolean).join(' ');
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: classes,
+        style: {
+            ...style,
+            width
+        }
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__wrap`
+    }, /*#__PURE__*/ _react.default.createElement(_forms.Error, {
+        message: errorMessage,
+        showError: showError
+    }), /*#__PURE__*/ _react.default.createElement(_forms.Label, {
+        htmlFor: `field-${path.replace(/\./g, '__')}`,
+        label: label,
+        required: required
+    }), /*#__PURE__*/ _react.default.createElement(_reacterrorboundary.ErrorBoundary, {
+        fallbackRender: fallbackRender,
+        onReset: (details)=>{}
+    }, /*#__PURE__*/ _react.default.createElement(_LexicalProvider.LexicalProvider, {
+        editorConfig: editorConfig,
+        fieldProps: props,
+        initialState: initialValue,
+        onChange: (editorState, editor, tags)=>{
+            const json = editorState.toJSON();
+            setValue(json);
+        },
+        readOnly: readOnly,
+        setValue: setValue,
+        value: value
+    }), /*#__PURE__*/ _react.default.createElement(_forms.FieldDescription, {
+        description: description,
+        value: value
+    })), /*#__PURE__*/ _react.default.createElement(_forms.FieldDescription, {
+        description: description,
+        value: value
+    })));
+};
+function fallbackRender({ error }) {
+    // Call resetErrorBoundary() to reset the error boundary and retry the render.
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        role: "alert"
+    }, /*#__PURE__*/ _react.default.createElement("p", null, "Something went wrong:"), /*#__PURE__*/ _react.default.createElement("pre", {
+        style: {
+            color: 'red'
+        }
+    }, error.message));
+}
+const _default = (0, _forms.withCondition)(RichText);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+import type { FeatureProvider } from '../types';
+export declare const BlockQuoteFeature: () => FeatureProvider;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/features/BlockQuote/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAO/C,eAAO,MAAM,iBAAiB,QAAO,eAyDpC,CAAA"}

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BlockQuoteFeature", {
+    enumerable: true,
+    get: function() {
+        return BlockQuoteFeature;
+    }
+});
+const _richtext = require("@lexical/rich-text");
+const _selection = require("@lexical/selection");
+const _lexical = require("lexical");
+const _LexicalMenu = require("../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu");
+const _Blockquote = require("../../lexical/ui/icons/Blockquote");
+const _floatingSelectToolbarTextDropdownSection = require("../common/floatingSelectToolbarTextDropdownSection");
+const _markdownTransformer = require("./markdownTransformer");
+const BlockQuoteFeature = ()=>{
+    return {
+        feature: ({ resolvedFeatures, unsanitizedEditorConfig })=>{
+            return {
+                floatingSelectToolbar: {
+                    sections: [
+                        (0, _floatingSelectToolbarTextDropdownSection.TextDropdownSectionWithEntries)([
+                            {
+                                ChildComponent: _Blockquote.BlockquoteIcon,
+                                isActive: ({ editor, selection })=>false,
+                                key: 'blockquote',
+                                label: `Blockquote`,
+                                onClick: ({ editor })=>{
+                                    //setHeading(editor, headingSize)
+                                    editor.update(()=>{
+                                        const selection = (0, _lexical.$getSelection)();
+                                        if ((0, _lexical.$isRangeSelection)(selection)) {
+                                            (0, _selection.$setBlocksType)(selection, ()=>(0, _richtext.$createQuoteNode)());
+                                        }
+                                    });
+                                },
+                                order: 20
+                            }
+                        ])
+                    ]
+                },
+                markdownTransformers: [
+                    _markdownTransformer.MarkdownTransformer
+                ],
+                nodes: [
+                    {
+                        node: _richtext.QuoteNode,
+                        type: _richtext.QuoteNode.getType()
+                    }
+                ],
+                props: null,
+                slashMenu: {
+                    options: [
+                        {
+                            options: [
+                                new _LexicalMenu.SlashMenuOption(`Blockquote`, {
+                                    Icon: _Blockquote.BlockquoteIcon,
+                                    keywords: [
+                                        'quote',
+                                        'blockquote'
+                                    ],
+                                    onSelect: ({ editor })=>{
+                                        const selection = (0, _lexical.$getSelection)();
+                                        if ((0, _lexical.$isRangeSelection)(selection)) {
+                                            (0, _selection.$setBlocksType)(selection, ()=>(0, _richtext.$createQuoteNode)());
+                                        }
+                                    }
+                                })
+                            ],
+                            title: 'Basic'
+                        }
+                    ]
+                }
+            };
+        },
+        key: 'blockquote'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/BlockQuote/markdownTransformer.d.ts

@@ -0,0 +1,3 @@
+import type { ElementTransformer } from '@lexical/markdown';
+export declare const MarkdownTransformer: ElementTransformer;
+//# sourceMappingURL=markdownTransformer.d.ts.map

package/dist/field/features/BlockQuote/markdownTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../src/field/features/BlockQuote/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAI3D,eAAO,MAAM,mBAAmB,EAAE,kBAmCjC,CAAA"}

package/dist/field/features/BlockQuote/markdownTransformer.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MarkdownTransformer", {
+    enumerable: true,
+    get: function() {
+        return MarkdownTransformer;
+    }
+});
+const _richtext = require("@lexical/rich-text");
+const _lexical = require("lexical");
+const MarkdownTransformer = {
+    dependencies: [
+        _richtext.QuoteNode
+    ],
+    export: (node, exportChildren)=>{
+        if (!(0, _richtext.$isQuoteNode)(node)) {
+            return null;
+        }
+        const lines = exportChildren(node).split('\n');
+        const output = [];
+        for (const line of lines){
+            output.push('> ' + line);
+        }
+        return output.join('\n');
+    },
+    regExp: /^>\s/,
+    replace: (parentNode, children, _match, isImport)=>{
+        if (isImport) {
+            const previousNode = parentNode.getPreviousSibling();
+            if ((0, _richtext.$isQuoteNode)(previousNode)) {
+                previousNode.splice(previousNode.getChildrenSize(), 0, [
+                    (0, _lexical.$createLineBreakNode)(),
+                    ...children
+                ]);
+                previousNode.select(0, 0);
+                parentNode.remove();
+                return;
+            }
+        }
+        const node = (0, _richtext.$createQuoteNode)();
+        node.append(...children);
+        parentNode.replace(node);
+        node.select(0, 0);
+    },
+    type: 'element'
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9CbG9ja1F1b3RlL21hcmtkb3duVHJhbnNmb3JtZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBFbGVtZW50VHJhbnNmb3JtZXIgfSBmcm9tICdAbGV4aWNhbC9tYXJrZG93bidcblxuaW1wb3J0IHsgJGNyZWF0ZVF1b3RlTm9kZSwgJGlzUXVvdGVOb2RlLCBRdW90ZU5vZGUgfSBmcm9tICdAbGV4aWNhbC9yaWNoLXRleHQnXG5pbXBvcnQgeyAkY3JlYXRlTGluZUJyZWFrTm9kZSB9IGZyb20gJ2xleGljYWwnXG5leHBvcnQgY29uc3QgTWFya2Rvd25UcmFuc2Zvcm1lcjogRWxlbWVudFRyYW5zZm9ybWVyID0ge1xuICBkZXBlbmRlbmNpZXM6IFtRdW90ZU5vZGVdLFxuICBleHBvcnQ6IChub2RlLCBleHBvcnRDaGlsZHJlbikgPT4ge1xuICAgIGlmICghJGlzUXVvdGVOb2RlKG5vZGUpKSB7XG4gICAgICByZXR1cm4gbnVsbFxuICAgIH1cblxuICAgIGNvbnN0IGxpbmVzID0gZXhwb3J0Q2hpbGRyZW4obm9kZSkuc3BsaXQoJ1xcbicpXG4gICAgY29uc3Qgb3V0cHV0ID0gW11cbiAgICBmb3IgKGNvbnN0IGxpbmUgb2YgbGluZXMpIHtcbiAgICAgIG91dHB1dC5wdXNoKCc+ICcgKyBsaW5lKVxuICAgIH1cbiAgICByZXR1cm4gb3V0cHV0LmpvaW4oJ1xcbicpXG4gIH0sXG4gIHJlZ0V4cDogL14+XFxzLyxcbiAgcmVwbGFjZTogKHBhcmVudE5vZGUsIGNoaWxkcmVuLCBfbWF0Y2gsIGlzSW1wb3J0KSA9PiB7XG4gICAgaWYgKGlzSW1wb3J0KSB7XG4gICAgICBjb25zdCBwcmV2aW91c05vZGUgPSBwYXJlbnROb2RlLmdldFByZXZpb3VzU2libGluZygpXG4gICAgICBpZiAoJGlzUXVvdGVOb2RlKHByZXZpb3VzTm9kZSkpIHtcbiAgICAgICAgcHJldmlvdXNOb2RlLnNwbGljZShwcmV2aW91c05vZGUuZ2V0Q2hpbGRyZW5TaXplKCksIDAsIFtcbiAgICAgICAgICAkY3JlYXRlTGluZUJyZWFrTm9kZSgpLFxuICAgICAgICAgIC4uLmNoaWxkcmVuLFxuICAgICAgICBdKVxuICAgICAgICBwcmV2aW91c05vZGUuc2VsZWN0KDAsIDApXG4gICAgICAgIHBhcmVudE5vZGUucmVtb3ZlKClcbiAgICAgICAgcmV0dXJuXG4gICAgICB9XG4gICAgfVxuXG4gICAgY29uc3Qgbm9kZSA9ICRjcmVhdGVRdW90ZU5vZGUoKVxuICAgIG5vZGUuYXBwZW5kKC4uLmNoaWxkcmVuKVxuICAgIHBhcmVudE5vZGUucmVwbGFjZShub2RlKVxuICAgIG5vZGUuc2VsZWN0KDAsIDApXG4gIH0sXG4gIHR5cGU6ICdlbGVtZW50Jyxcbn1cbiJdLCJuYW1lcyI6WyJNYXJrZG93blRyYW5zZm9ybWVyIiwiZGVwZW5kZW5jaWVzIiwiUXVvdGVOb2RlIiwiZXhwb3J0Iiwibm9kZSIsImV4cG9ydENoaWxkcmVuIiwiJGlzUXVvdGVOb2RlIiwibGluZXMiLCJzcGxpdCIsIm91dHB1dCIsImxpbmUiLCJwdXNoIiwiam9pbiIsInJlZ0V4cCIsInJlcGxhY2UiLCJwYXJlbnROb2RlIiwiY2hpbGRyZW4iLCJfbWF0Y2giLCJpc0ltcG9ydCIsInByZXZpb3VzTm9kZSIsImdldFByZXZpb3VzU2libGluZyIsInNwbGljZSIsImdldENoaWxkcmVuU2l6ZSIsIiRjcmVhdGVMaW5lQnJlYWtOb2RlIiwic2VsZWN0IiwicmVtb3ZlIiwiJGNyZWF0ZVF1b3RlTm9kZSIsImFwcGVuZCIsInR5cGUiXSwibWFwcGluZ3MiOiI7Ozs7K0JBSWFBOzs7ZUFBQUE7OzswQkFGNkM7eUJBQ3JCO0FBQzlCLE1BQU1BLHNCQUEwQztJQUNyREMsY0FBYztRQUFDQyxtQkFBUztLQUFDO0lBQ3pCQyxRQUFRLENBQUNDLE1BQU1DO1FBQ2IsSUFBSSxDQUFDQyxJQUFBQSxzQkFBWSxFQUFDRixPQUFPO1lBQ3ZCLE9BQU87UUFDVDtRQUVBLE1BQU1HLFFBQVFGLGVBQWVELE1BQU1JLEtBQUssQ0FBQztRQUN6QyxNQUFNQyxTQUFTLEVBQUU7UUFDakIsS0FBSyxNQUFNQyxRQUFRSCxNQUFPO1lBQ3hCRSxPQUFPRSxJQUFJLENBQUMsT0FBT0Q7UUFDckI7UUFDQSxPQUFPRCxPQUFPRyxJQUFJLENBQUM7SUFDckI7SUFDQUMsUUFBUTtJQUNSQyxTQUFTLENBQUNDLFlBQVlDLFVBQVVDLFFBQVFDO1FBQ3RDLElBQUlBLFVBQVU7WUFDWixNQUFNQyxlQUFlSixXQUFXSyxrQkFBa0I7WUFDbEQsSUFBSWQsSUFBQUEsc0JBQVksRUFBQ2EsZUFBZTtnQkFDOUJBLGFBQWFFLE1BQU0sQ0FBQ0YsYUFBYUcsZUFBZSxJQUFJLEdBQUc7b0JBQ3JEQyxJQUFBQSw2QkFBb0I7dUJBQ2pCUDtpQkFDSjtnQkFDREcsYUFBYUssTUFBTSxDQUFDLEdBQUc7Z0JBQ3ZCVCxXQUFXVSxNQUFNO2dCQUNqQjtZQUNGO1FBQ0Y7UUFFQSxNQUFNckIsT0FBT3NCLElBQUFBLDBCQUFnQjtRQUM3QnRCLEtBQUt1QixNQUFNLElBQUlYO1FBQ2ZELFdBQVdELE9BQU8sQ0FBQ1Y7UUFDbkJBLEtBQUtvQixNQUFNLENBQUMsR0FBRztJQUNqQjtJQUNBSSxNQUFNO0FBQ1IifQ==

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

@@ -0,0 +1,12 @@
+import type { Data, FieldWithPath } from 'payload/types';
+import type React from 'react';
+import './index.scss';
+type Props = {
+    fieldSchema: FieldWithPath[];
+    onChange?: ({ formData }: {
+        formData: Data;
+    }) => void;
+};
+export declare const FormSavePlugin: React.FC<Props>;
+export {};
+//# sourceMappingURL=FormSavePlugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FormSavePlugin.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Blocks/component/FormSavePlugin.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AACxD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAK9B,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,WAAW,EAAE,aAAa,EAAE,CAAA;IAC5B,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAA;KAAE,KAAK,IAAI,CAAA;CACtD,CAAA;AAED,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAgB1C,CAAA"}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FormSavePlugin", {
+    enumerable: true,
+    get: function() {
+        return FormSavePlugin;
+    }
+});
+const _forms = require("payload/components/forms");
+const _react = require("react");
+require("./index.scss");
+const FormSavePlugin = (props)=>{
+    const { onChange } = props;
+    const [fields, dispatchFields] = (0, _forms.useAllFormFields)();
+    // Pass in fields, and indicate if you'd like to "unflatten" field data.
+    // The result below will reflect the data stored in the form at the given time
+    const formData = (0, _forms.reduceFieldsToValues)(fields, true);
+    (0, _react.useEffect)(()=>{
+        if (onChange) {
+            onChange({
+                formData
+            });
+        }
+    }, [
+        formData,
+        onChange
+    ]);
+    return null;
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9CbG9ja3MvY29tcG9uZW50L0Zvcm1TYXZlUGx1Z2luLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IERhdGEsIEZpZWxkV2l0aFBhdGggfSBmcm9tICdwYXlsb2FkL3R5cGVzJ1xuaW1wb3J0IHR5cGUgUmVhY3QgZnJvbSAncmVhY3QnXG5cbmltcG9ydCB7IHJlZHVjZUZpZWxkc1RvVmFsdWVzLCB1c2VBbGxGb3JtRmllbGRzIH0gZnJvbSAncGF5bG9hZC9jb21wb25lbnRzL2Zvcm1zJ1xuaW1wb3J0IHsgdXNlRWZmZWN0IH0gZnJvbSAncmVhY3QnXG5cbmltcG9ydCAnLi9pbmRleC5zY3NzJ1xuXG50eXBlIFByb3BzID0ge1xuICBmaWVsZFNjaGVtYTogRmllbGRXaXRoUGF0aFtdXG4gIG9uQ2hhbmdlPzogKHsgZm9ybURhdGEgfTogeyBmb3JtRGF0YTogRGF0YSB9KSA9PiB2b2lkXG59XG5cbmV4cG9ydCBjb25zdCBGb3JtU2F2ZVBsdWdpbjogUmVhY3QuRkM8UHJvcHM+ID0gKHByb3BzKSA9PiB7XG4gIGNvbnN0IHsgb25DaGFuZ2UgfSA9IHByb3BzXG5cbiAgY29uc3QgW2ZpZWxkcywgZGlzcGF0Y2hGaWVsZHNdID0gdXNlQWxsRm9ybUZpZWxkcygpXG5cbiAgLy8gUGFzcyBpbiBmaWVsZHMsIGFuZCBpbmRpY2F0ZSBpZiB5b3UnZCBsaWtlIHRvIFwidW5mbGF0dGVuXCIgZmllbGQgZGF0YS5cbiAgLy8gVGhlIHJlc3VsdCBiZWxvdyB3aWxsIHJlZmxlY3QgdGhlIGRhdGEgc3RvcmVkIGluIHRoZSBmb3JtIGF0IHRoZSBnaXZlbiB0aW1lXG4gIGNvbnN0IGZvcm1EYXRhID0gcmVkdWNlRmllbGRzVG9WYWx1ZXMoZmllbGRzLCB0cnVlKVxuXG4gIHVzZUVmZmVjdCgoKSA9PiB7XG4gICAgaWYgKG9uQ2hhbmdlKSB7XG4gICAgICBvbkNoYW5nZSh7IGZvcm1EYXRhIH0pXG4gICAgfVxuICB9LCBbZm9ybURhdGEsIG9uQ2hhbmdlXSlcblxuICByZXR1cm4gbnVsbFxufVxuIl0sIm5hbWVzIjpbIkZvcm1TYXZlUGx1Z2luIiwicHJvcHMiLCJvbkNoYW5nZSIsImZpZWxkcyIsImRpc3BhdGNoRmllbGRzIiwidXNlQWxsRm9ybUZpZWxkcyIsImZvcm1EYXRhIiwicmVkdWNlRmllbGRzVG9WYWx1ZXMiLCJ1c2VFZmZlY3QiXSwibWFwcGluZ3MiOiI7Ozs7K0JBYWFBOzs7ZUFBQUE7Ozt1QkFWMEM7dUJBQzdCO1FBRW5CO0FBT0EsTUFBTUEsaUJBQWtDLENBQUNDO0lBQzlDLE1BQU0sRUFBRUMsUUFBUSxFQUFFLEdBQUdEO0lBRXJCLE1BQU0sQ0FBQ0UsUUFBUUMsZUFBZSxHQUFHQyxJQUFBQSx1QkFBZ0I7SUFFakQsd0VBQXdFO0lBQ3hFLDhFQUE4RTtJQUM5RSxNQUFNQyxXQUFXQyxJQUFBQSwyQkFBb0IsRUFBQ0osUUFBUTtJQUU5Q0ssSUFBQUEsZ0JBQVMsRUFBQztRQUNSLElBQUlOLFVBQVU7WUFDWkEsU0FBUztnQkFBRUk7WUFBUztRQUN0QjtJQUNGLEdBQUc7UUFBQ0E7UUFBVUo7S0FBUztJQUV2QixPQUFPO0FBQ1QifQ==

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

@@ -0,0 +1,14 @@
+import { type ElementFormatType } from 'lexical';
+import React from 'react';
+import { type BlockFields } from '../nodes/BlocksNode';
+import './index.scss';
+type Props = {
+    children?: React.ReactNode;
+    className?: string;
+    fields: BlockFields;
+    format?: ElementFormatType;
+    nodeKey?: string;
+};
+export declare const BlockComponent: React.FC<Props>;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

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