@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/field/features/lists/OrderedList/markdownTransformer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ORDERED_LIST", {
+    enumerable: true,
+    get: function() {
+        return ORDERED_LIST;
+    }
+});
+const _list = require("@lexical/list");
+const _markdown = require("../common/markdown");
+const ORDERED_LIST = {
+    dependencies: [
+        _list.ListNode,
+        _list.ListItemNode
+    ],
+    export: (node, exportChildren)=>{
+        return (0, _list.$isListNode)(node) ? (0, _markdown.listExport)(node, exportChildren, 0) : null;
+    },
+    regExp: /^(\s*)(\d+)\.\s/,
+    replace: (0, _markdown.listReplace)('number'),
+    type: 'element'
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9saXN0cy9PcmRlcmVkTGlzdC9tYXJrZG93blRyYW5zZm9ybWVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRWxlbWVudFRyYW5zZm9ybWVyIH0gZnJvbSAnQGxleGljYWwvbWFya2Rvd24nXG5cbmltcG9ydCB7ICRpc0xpc3ROb2RlLCBMaXN0SXRlbU5vZGUsIExpc3ROb2RlIH0gZnJvbSAnQGxleGljYWwvbGlzdCdcblxuaW1wb3J0IHsgbGlzdEV4cG9ydCwgbGlzdFJlcGxhY2UgfSBmcm9tICcuLi9jb21tb24vbWFya2Rvd24nXG5cbmV4cG9ydCBjb25zdCBPUkRFUkVEX0xJU1Q6IEVsZW1lbnRUcmFuc2Zvcm1lciA9IHtcbiAgZGVwZW5kZW5jaWVzOiBbTGlzdE5vZGUsIExpc3RJdGVtTm9kZV0sXG4gIGV4cG9ydDogKG5vZGUsIGV4cG9ydENoaWxkcmVuKSA9PiB7XG4gICAgcmV0dXJuICRpc0xpc3ROb2RlKG5vZGUpID8gbGlzdEV4cG9ydChub2RlLCBleHBvcnRDaGlsZHJlbiwgMCkgOiBudWxsXG4gIH0sXG4gIHJlZ0V4cDogL14oXFxzKikoXFxkKylcXC5cXHMvLFxuICByZXBsYWNlOiBsaXN0UmVwbGFjZSgnbnVtYmVyJyksXG4gIHR5cGU6ICdlbGVtZW50Jyxcbn1cbiJdLCJuYW1lcyI6WyJPUkRFUkVEX0xJU1QiLCJkZXBlbmRlbmNpZXMiLCJMaXN0Tm9kZSIsIkxpc3RJdGVtTm9kZSIsImV4cG9ydCIsIm5vZGUiLCJleHBvcnRDaGlsZHJlbiIsIiRpc0xpc3ROb2RlIiwibGlzdEV4cG9ydCIsInJlZ0V4cCIsInJlcGxhY2UiLCJsaXN0UmVwbGFjZSIsInR5cGUiXSwibWFwcGluZ3MiOiI7Ozs7K0JBTWFBOzs7ZUFBQUE7OztzQkFKdUM7MEJBRVo7QUFFakMsTUFBTUEsZUFBbUM7SUFDOUNDLGNBQWM7UUFBQ0MsY0FBUTtRQUFFQyxrQkFBWTtLQUFDO0lBQ3RDQyxRQUFRLENBQUNDLE1BQU1DO1FBQ2IsT0FBT0MsSUFBQUEsaUJBQVcsRUFBQ0YsUUFBUUcsSUFBQUEsb0JBQVUsRUFBQ0gsTUFBTUMsZ0JBQWdCLEtBQUs7SUFDbkU7SUFDQUcsUUFBUTtJQUNSQyxTQUFTQyxJQUFBQSxxQkFBVyxFQUFDO0lBQ3JCQyxNQUFNO0FBQ1IifQ==

package/dist/field/features/lists/UnorderedList/index.d.ts

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

package/dist/field/features/lists/UnorderedList/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/UnorderedList/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAMlD,eAAO,MAAM,mBAAmB,QAAO,eA0CtC,CAAA"}

package/dist/field/features/lists/UnorderedList/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UnoderedListFeature", {
+    enumerable: true,
+    get: function() {
+        return UnoderedListFeature;
+    }
+});
+const _list = require("@lexical/list");
+const _LexicalListPlugin = require("@lexical/react/LexicalListPlugin");
+const _LexicalMenu = require("../../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu");
+const _UnorderedList = require("../../../lexical/ui/icons/UnorderedList");
+const _markdownTransformer = require("./markdownTransformer");
+const UnoderedListFeature = ()=>{
+    return {
+        feature: ({ resolvedFeatures, unsanitizedEditorConfig })=>{
+            return {
+                markdownTransformers: [
+                    _markdownTransformer.UNORDERED_LIST
+                ],
+                nodes: [
+                    {
+                        node: _list.ListNode,
+                        type: _list.ListNode.getType()
+                    },
+                    {
+                        node: _list.ListItemNode,
+                        type: _list.ListItemNode.getType()
+                    }
+                ],
+                plugins: [
+                    {
+                        Component: _LexicalListPlugin.ListPlugin,
+                        position: 'normal'
+                    }
+                ],
+                props: null,
+                slashMenu: {
+                    options: [
+                        {
+                            options: [
+                                new _LexicalMenu.SlashMenuOption('Unordered List', {
+                                    Icon: _UnorderedList.UnorderedListIcon,
+                                    keywords: [
+                                        'unordered list',
+                                        'ul'
+                                    ],
+                                    onSelect: ({ editor })=>{
+                                        editor.dispatchCommand(_list.INSERT_UNORDERED_LIST_COMMAND, undefined);
+                                    }
+                                })
+                            ],
+                            title: 'Lists'
+                        }
+                    ]
+                }
+            };
+        },
+        key: 'unorderedList'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/lists/UnorderedList/markdownTransformer.d.ts

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

package/dist/field/features/lists/UnorderedList/markdownTransformer.d.ts.map

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

package/dist/field/features/lists/UnorderedList/markdownTransformer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UNORDERED_LIST", {
+    enumerable: true,
+    get: function() {
+        return UNORDERED_LIST;
+    }
+});
+const _list = require("@lexical/list");
+const _markdown = require("../common/markdown");
+const UNORDERED_LIST = {
+    dependencies: [
+        _list.ListNode,
+        _list.ListItemNode
+    ],
+    export: (node, exportChildren)=>{
+        return (0, _list.$isListNode)(node) ? (0, _markdown.listExport)(node, exportChildren, 0) : null;
+    },
+    regExp: /^(\s*)[-*+]\s/,
+    replace: (0, _markdown.listReplace)('bullet'),
+    type: 'element'
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9saXN0cy9Vbm9yZGVyZWRMaXN0L21hcmtkb3duVHJhbnNmb3JtZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBFbGVtZW50VHJhbnNmb3JtZXIgfSBmcm9tICdAbGV4aWNhbC9tYXJrZG93bidcblxuaW1wb3J0IHsgJGlzTGlzdE5vZGUsIExpc3RJdGVtTm9kZSwgTGlzdE5vZGUgfSBmcm9tICdAbGV4aWNhbC9saXN0J1xuXG5pbXBvcnQgeyBsaXN0RXhwb3J0LCBsaXN0UmVwbGFjZSB9IGZyb20gJy4uL2NvbW1vbi9tYXJrZG93bidcblxuZXhwb3J0IGNvbnN0IFVOT1JERVJFRF9MSVNUOiBFbGVtZW50VHJhbnNmb3JtZXIgPSB7XG4gIGRlcGVuZGVuY2llczogW0xpc3ROb2RlLCBMaXN0SXRlbU5vZGVdLFxuICBleHBvcnQ6IChub2RlLCBleHBvcnRDaGlsZHJlbikgPT4ge1xuICAgIHJldHVybiAkaXNMaXN0Tm9kZShub2RlKSA/IGxpc3RFeHBvcnQobm9kZSwgZXhwb3J0Q2hpbGRyZW4sIDApIDogbnVsbFxuICB9LFxuICByZWdFeHA6IC9eKFxccyopWy0qK11cXHMvLFxuICByZXBsYWNlOiBsaXN0UmVwbGFjZSgnYnVsbGV0JyksXG4gIHR5cGU6ICdlbGVtZW50Jyxcbn1cbiJdLCJuYW1lcyI6WyJVTk9SREVSRURfTElTVCIsImRlcGVuZGVuY2llcyIsIkxpc3ROb2RlIiwiTGlzdEl0ZW1Ob2RlIiwiZXhwb3J0Iiwibm9kZSIsImV4cG9ydENoaWxkcmVuIiwiJGlzTGlzdE5vZGUiLCJsaXN0RXhwb3J0IiwicmVnRXhwIiwicmVwbGFjZSIsImxpc3RSZXBsYWNlIiwidHlwZSJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFNYUE7OztlQUFBQTs7O3NCQUp1QzswQkFFWjtBQUVqQyxNQUFNQSxpQkFBcUM7SUFDaERDLGNBQWM7UUFBQ0MsY0FBUTtRQUFFQyxrQkFBWTtLQUFDO0lBQ3RDQyxRQUFRLENBQUNDLE1BQU1DO1FBQ2IsT0FBT0MsSUFBQUEsaUJBQVcsRUFBQ0YsUUFBUUcsSUFBQUEsb0JBQVUsRUFBQ0gsTUFBTUMsZ0JBQWdCLEtBQUs7SUFDbkU7SUFDQUcsUUFBUTtJQUNSQyxTQUFTQyxJQUFBQSxxQkFBVyxFQUFDO0lBQ3JCQyxNQUFNO0FBQ1IifQ==

package/dist/field/features/lists/common/markdown.d.ts

@@ -0,0 +1,6 @@
+import type { ListNode, ListType } from '@lexical/list';
+import type { ElementTransformer } from '@lexical/markdown';
+import type { ElementNode } from 'lexical';
+export declare const listReplace: (listType: ListType) => ElementTransformer['replace'];
+export declare const listExport: (listNode: ListNode, exportChildren: (node: ElementNode) => string, depth: number) => string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/field/features/lists/common/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/common/markdown.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAO1C,eAAO,MAAM,WAAW,aAAc,QAAQ,KAAG,kBAAkB,CAAC,SAAS,CA6B5E,CAAA;AAED,eAAO,MAAM,UAAU,aACX,QAAQ,yBACK,WAAW,KAAK,MAAM,SACtC,MAAM,KACZ,MA2BF,CAAA"}

package/dist/field/features/lists/common/markdown.js

@@ -0,0 +1,76 @@
+// Copied from https://github.com/facebook/lexical/blob/176b8cf16ecb332ee5efe2c75219e223b7b019f2/packages/lexical-markdown/src/MarkdownTransformers.ts#L97C1-L172C1
+"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, {
+    listReplace: function() {
+        return listReplace;
+    },
+    listExport: function() {
+        return listExport;
+    }
+});
+const _list = require("@lexical/list");
+// Amount of spaces that define indentation level
+const LIST_INDENT_SIZE = 4;
+const listReplace = (listType)=>{
+    return (parentNode, children, match)=>{
+        const previousNode = parentNode.getPreviousSibling();
+        const nextNode = parentNode.getNextSibling();
+        const listItem = (0, _list.$createListItemNode)(listType === 'check' ? match[3] === 'x' : undefined);
+        if ((0, _list.$isListNode)(nextNode) && nextNode.getListType() === listType) {
+            const firstChild = nextNode.getFirstChild();
+            if (firstChild !== null) {
+                firstChild.insertBefore(listItem);
+            } else {
+                // should never happen, but let's handle gracefully, just in case.
+                nextNode.append(listItem);
+            }
+            parentNode.remove();
+        } else if ((0, _list.$isListNode)(previousNode) && previousNode.getListType() === listType) {
+            previousNode.append(listItem);
+            parentNode.remove();
+        } else {
+            const list = (0, _list.$createListNode)(listType, listType === 'number' ? Number(match[2]) : undefined);
+            list.append(listItem);
+            parentNode.replace(list);
+        }
+        listItem.append(...children);
+        listItem.select(0, 0);
+        const indent = Math.floor(match[1].length / LIST_INDENT_SIZE);
+        if (indent) {
+            listItem.setIndent(indent);
+        }
+    };
+};
+const listExport = (listNode, exportChildren, depth)=>{
+    const output = [];
+    const children = listNode.getChildren();
+    let index = 0;
+    for (const listItemNode of children){
+        if ((0, _list.$isListItemNode)(listItemNode)) {
+            if (listItemNode.getChildrenSize() === 1) {
+                const firstChild = listItemNode.getFirstChild();
+                if ((0, _list.$isListNode)(firstChild)) {
+                    output.push(listExport(firstChild, exportChildren, depth + 1));
+                    continue;
+                }
+            }
+            const indent = ' '.repeat(depth * LIST_INDENT_SIZE);
+            const listType = listNode.getListType();
+            const prefix = listType === 'number' ? `${listNode.getStart() + index}. ` : listType === 'check' ? `- [${listItemNode.getChecked() ? 'x' : ' '}] ` : '- ';
+            output.push(indent + prefix + exportChildren(listItemNode));
+            index++;
+        }
+    }
+    return output.join('\n');
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9saXN0cy9jb21tb24vbWFya2Rvd24udHMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29waWVkIGZyb20gaHR0cHM6Ly9naXRodWIuY29tL2ZhY2Vib29rL2xleGljYWwvYmxvYi8xNzZiOGNmMTZlY2IzMzJlZTVlZmUyYzc1MjE5ZTIyM2I3YjAxOWYyL3BhY2thZ2VzL2xleGljYWwtbWFya2Rvd24vc3JjL01hcmtkb3duVHJhbnNmb3JtZXJzLnRzI0w5N0MxLUwxNzJDMVxuXG5pbXBvcnQgdHlwZSB7IExpc3ROb2RlLCBMaXN0VHlwZSB9IGZyb20gJ0BsZXhpY2FsL2xpc3QnXG5pbXBvcnQgdHlwZSB7IEVsZW1lbnRUcmFuc2Zvcm1lciB9IGZyb20gJ0BsZXhpY2FsL21hcmtkb3duJ1xuaW1wb3J0IHR5cGUgeyBFbGVtZW50Tm9kZSB9IGZyb20gJ2xleGljYWwnXG5cbmltcG9ydCB7ICRjcmVhdGVMaXN0SXRlbU5vZGUsICRjcmVhdGVMaXN0Tm9kZSwgJGlzTGlzdEl0ZW1Ob2RlLCAkaXNMaXN0Tm9kZSB9IGZyb20gJ0BsZXhpY2FsL2xpc3QnXG5cbi8vIEFtb3VudCBvZiBzcGFjZXMgdGhhdCBkZWZpbmUgaW5kZW50YXRpb24gbGV2ZWxcbmNvbnN0IExJU1RfSU5ERU5UX1NJWkUgPSA0XG5cbmV4cG9ydCBjb25zdCBsaXN0UmVwbGFjZSA9IChsaXN0VHlwZTogTGlzdFR5cGUpOiBFbGVtZW50VHJhbnNmb3JtZXJbJ3JlcGxhY2UnXSA9PiB7XG4gIHJldHVybiAocGFyZW50Tm9kZSwgY2hpbGRyZW4sIG1hdGNoKSA9PiB7XG4gICAgY29uc3QgcHJldmlvdXNOb2RlID0gcGFyZW50Tm9kZS5nZXRQcmV2aW91c1NpYmxpbmcoKVxuICAgIGNvbnN0IG5leHROb2RlID0gcGFyZW50Tm9kZS5nZXROZXh0U2libGluZygpXG4gICAgY29uc3QgbGlzdEl0ZW0gPSAkY3JlYXRlTGlzdEl0ZW1Ob2RlKGxpc3RUeXBlID09PSAnY2hlY2snID8gbWF0Y2hbM10gPT09ICd4JyA6IHVuZGVmaW5lZClcbiAgICBpZiAoJGlzTGlzdE5vZGUobmV4dE5vZGUpICYmIG5leHROb2RlLmdldExpc3RUeXBlKCkgPT09IGxpc3RUeXBlKSB7XG4gICAgICBjb25zdCBmaXJzdENoaWxkID0gbmV4dE5vZGUuZ2V0Rmlyc3RDaGlsZCgpXG4gICAgICBpZiAoZmlyc3RDaGlsZCAhPT0gbnVsbCkge1xuICAgICAgICBmaXJzdENoaWxkLmluc2VydEJlZm9yZShsaXN0SXRlbSlcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIC8vIHNob3VsZCBuZXZlciBoYXBwZW4sIGJ1dCBsZXQncyBoYW5kbGUgZ3JhY2VmdWxseSwganVzdCBpbiBjYXNlLlxuICAgICAgICBuZXh0Tm9kZS5hcHBlbmQobGlzdEl0ZW0pXG4gICAgICB9XG4gICAgICBwYXJlbnROb2RlLnJlbW92ZSgpXG4gICAgfSBlbHNlIGlmICgkaXNMaXN0Tm9kZShwcmV2aW91c05vZGUpICYmIHByZXZpb3VzTm9kZS5nZXRMaXN0VHlwZSgpID09PSBsaXN0VHlwZSkge1xuICAgICAgcHJldmlvdXNOb2RlLmFwcGVuZChsaXN0SXRlbSlcbiAgICAgIHBhcmVudE5vZGUucmVtb3ZlKClcbiAgICB9IGVsc2Uge1xuICAgICAgY29uc3QgbGlzdCA9ICRjcmVhdGVMaXN0Tm9kZShsaXN0VHlwZSwgbGlzdFR5cGUgPT09ICdudW1iZXInID8gTnVtYmVyKG1hdGNoWzJdKSA6IHVuZGVmaW5lZClcbiAgICAgIGxpc3QuYXBwZW5kKGxpc3RJdGVtKVxuICAgICAgcGFyZW50Tm9kZS5yZXBsYWNlKGxpc3QpXG4gICAgfVxuICAgIGxpc3RJdGVtLmFwcGVuZCguLi5jaGlsZHJlbilcbiAgICBsaXN0SXRlbS5zZWxlY3QoMCwgMClcbiAgICBjb25zdCBpbmRlbnQgPSBNYXRoLmZsb29yKG1hdGNoWzFdLmxlbmd0aCAvIExJU1RfSU5ERU5UX1NJWkUpXG4gICAgaWYgKGluZGVudCkge1xuICAgICAgbGlzdEl0ZW0uc2V0SW5kZW50KGluZGVudClcbiAgICB9XG4gIH1cbn1cblxuZXhwb3J0IGNvbnN0IGxpc3RFeHBvcnQgPSAoXG4gIGxpc3ROb2RlOiBMaXN0Tm9kZSxcbiAgZXhwb3J0Q2hpbGRyZW46IChub2RlOiBFbGVtZW50Tm9kZSkgPT4gc3RyaW5nLFxuICBkZXB0aDogbnVtYmVyLFxuKTogc3RyaW5nID0+IHtcbiAgY29uc3Qgb3V0cHV0ID0gW11cbiAgY29uc3QgY2hpbGRyZW4gPSBsaXN0Tm9kZS5nZXRDaGlsZHJlbigpXG4gIGxldCBpbmRleCA9IDBcbiAgZm9yIChjb25zdCBsaXN0SXRlbU5vZGUgb2YgY2hpbGRyZW4pIHtcbiAgICBpZiAoJGlzTGlzdEl0ZW1Ob2RlKGxpc3RJdGVtTm9kZSkpIHtcbiAgICAgIGlmIChsaXN0SXRlbU5vZGUuZ2V0Q2hpbGRyZW5TaXplKCkgPT09IDEpIHtcbiAgICAgICAgY29uc3QgZmlyc3RDaGlsZCA9IGxpc3RJdGVtTm9kZS5nZXRGaXJzdENoaWxkKClcbiAgICAgICAgaWYgKCRpc0xpc3ROb2RlKGZpcnN0Q2hpbGQpKSB7XG4gICAgICAgICAgb3V0cHV0LnB1c2gobGlzdEV4cG9ydChmaXJzdENoaWxkLCBleHBvcnRDaGlsZHJlbiwgZGVwdGggKyAxKSlcbiAgICAgICAgICBjb250aW51ZVxuICAgICAgICB9XG4gICAgICB9XG4gICAgICBjb25zdCBpbmRlbnQgPSAnICcucmVwZWF0KGRlcHRoICogTElTVF9JTkRFTlRfU0laRSlcbiAgICAgIGNvbnN0IGxpc3RUeXBlID0gbGlzdE5vZGUuZ2V0TGlzdFR5cGUoKVxuICAgICAgY29uc3QgcHJlZml4ID1cbiAgICAgICAgbGlzdFR5cGUgPT09ICdudW1iZXInXG4gICAgICAgICAgPyBgJHtsaXN0Tm9kZS5nZXRTdGFydCgpICsgaW5kZXh9LiBgXG4gICAgICAgICAgOiBsaXN0VHlwZSA9PT0gJ2NoZWNrJ1xuICAgICAgICAgID8gYC0gWyR7bGlzdEl0ZW1Ob2RlLmdldENoZWNrZWQoKSA/ICd4JyA6ICcgJ31dIGBcbiAgICAgICAgICA6ICctICdcbiAgICAgIG91dHB1dC5wdXNoKGluZGVudCArIHByZWZpeCArIGV4cG9ydENoaWxkcmVuKGxpc3RJdGVtTm9kZSkpXG4gICAgICBpbmRleCsrXG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIG91dHB1dC5qb2luKCdcXG4nKVxufVxuIl0sIm5hbWVzIjpbImxpc3RSZXBsYWNlIiwibGlzdEV4cG9ydCIsIkxJU1RfSU5ERU5UX1NJWkUiLCJsaXN0VHlwZSIsInBhcmVudE5vZGUiLCJjaGlsZHJlbiIsIm1hdGNoIiwicHJldmlvdXNOb2RlIiwiZ2V0UHJldmlvdXNTaWJsaW5nIiwibmV4dE5vZGUiLCJnZXROZXh0U2libGluZyIsImxpc3RJdGVtIiwiJGNyZWF0ZUxpc3RJdGVtTm9kZSIsInVuZGVmaW5lZCIsIiRpc0xpc3ROb2RlIiwiZ2V0TGlzdFR5cGUiLCJmaXJzdENoaWxkIiwiZ2V0Rmlyc3RDaGlsZCIsImluc2VydEJlZm9yZSIsImFwcGVuZCIsInJlbW92ZSIsImxpc3QiLCIkY3JlYXRlTGlzdE5vZGUiLCJOdW1iZXIiLCJyZXBsYWNlIiwic2VsZWN0IiwiaW5kZW50IiwiTWF0aCIsImZsb29yIiwibGVuZ3RoIiwic2V0SW5kZW50IiwibGlzdE5vZGUiLCJleHBvcnRDaGlsZHJlbiIsImRlcHRoIiwib3V0cHV0IiwiZ2V0Q2hpbGRyZW4iLCJpbmRleCIsImxpc3RJdGVtTm9kZSIsIiRpc0xpc3RJdGVtTm9kZSIsImdldENoaWxkcmVuU2l6ZSIsInB1c2giLCJyZXBlYXQiLCJwcmVmaXgiLCJnZXRTdGFydCIsImdldENoZWNrZWQiLCJqb2luIl0sIm1hcHBpbmdzIjoiQUFBQSxtS0FBbUs7Ozs7Ozs7Ozs7OztJQVd0SkEsV0FBVztlQUFYQTs7SUErQkFDLFVBQVU7ZUFBVkE7OztzQkFwQ3NFO0FBRW5GLGlEQUFpRDtBQUNqRCxNQUFNQyxtQkFBbUI7QUFFbEIsTUFBTUYsY0FBYyxDQUFDRztJQUMxQixPQUFPLENBQUNDLFlBQVlDLFVBQVVDO1FBQzVCLE1BQU1DLGVBQWVILFdBQVdJLGtCQUFrQjtRQUNsRCxNQUFNQyxXQUFXTCxXQUFXTSxjQUFjO1FBQzFDLE1BQU1DLFdBQVdDLElBQUFBLHlCQUFtQixFQUFDVCxhQUFhLFVBQVVHLEtBQUssQ0FBQyxFQUFFLEtBQUssTUFBTU87UUFDL0UsSUFBSUMsSUFBQUEsaUJBQVcsRUFBQ0wsYUFBYUEsU0FBU00sV0FBVyxPQUFPWixVQUFVO1lBQ2hFLE1BQU1hLGFBQWFQLFNBQVNRLGFBQWE7WUFDekMsSUFBSUQsZUFBZSxNQUFNO2dCQUN2QkEsV0FBV0UsWUFBWSxDQUFDUDtZQUMxQixPQUFPO2dCQUNMLGtFQUFrRTtnQkFDbEVGLFNBQVNVLE1BQU0sQ0FBQ1I7WUFDbEI7WUFDQVAsV0FBV2dCLE1BQU07UUFDbkIsT0FBTyxJQUFJTixJQUFBQSxpQkFBVyxFQUFDUCxpQkFBaUJBLGFBQWFRLFdBQVcsT0FBT1osVUFBVTtZQUMvRUksYUFBYVksTUFBTSxDQUFDUjtZQUNwQlAsV0FBV2dCLE1BQU07UUFDbkIsT0FBTztZQUNMLE1BQU1DLE9BQU9DLElBQUFBLHFCQUFlLEVBQUNuQixVQUFVQSxhQUFhLFdBQVdvQixPQUFPakIsS0FBSyxDQUFDLEVBQUUsSUFBSU87WUFDbEZRLEtBQUtGLE1BQU0sQ0FBQ1I7WUFDWlAsV0FBV29CLE9BQU8sQ0FBQ0g7UUFDckI7UUFDQVYsU0FBU1EsTUFBTSxJQUFJZDtRQUNuQk0sU0FBU2MsTUFBTSxDQUFDLEdBQUc7UUFDbkIsTUFBTUMsU0FBU0MsS0FBS0MsS0FBSyxDQUFDdEIsS0FBSyxDQUFDLEVBQUUsQ0FBQ3VCLE1BQU0sR0FBRzNCO1FBQzVDLElBQUl3QixRQUFRO1lBQ1ZmLFNBQVNtQixTQUFTLENBQUNKO1FBQ3JCO0lBQ0Y7QUFDRjtBQUVPLE1BQU16QixhQUFhLENBQ3hCOEIsVUFDQUMsZ0JBQ0FDO0lBRUEsTUFBTUMsU0FBUyxFQUFFO0lBQ2pCLE1BQU03QixXQUFXMEIsU0FBU0ksV0FBVztJQUNyQyxJQUFJQyxRQUFRO0lBQ1osS0FBSyxNQUFNQyxnQkFBZ0JoQyxTQUFVO1FBQ25DLElBQUlpQyxJQUFBQSxxQkFBZSxFQUFDRCxlQUFlO1lBQ2pDLElBQUlBLGFBQWFFLGVBQWUsT0FBTyxHQUFHO2dCQUN4QyxNQUFNdkIsYUFBYXFCLGFBQWFwQixhQUFhO2dCQUM3QyxJQUFJSCxJQUFBQSxpQkFBVyxFQUFDRSxhQUFhO29CQUMzQmtCLE9BQU9NLElBQUksQ0FBQ3ZDLFdBQVdlLFlBQVlnQixnQkFBZ0JDLFFBQVE7b0JBQzNEO2dCQUNGO1lBQ0Y7WUFDQSxNQUFNUCxTQUFTLElBQUllLE1BQU0sQ0FBQ1IsUUFBUS9CO1lBQ2xDLE1BQU1DLFdBQVc0QixTQUFTaEIsV0FBVztZQUNyQyxNQUFNMkIsU0FDSnZDLGFBQWEsV0FDVCxDQUFDLEVBQUU0QixTQUFTWSxRQUFRLEtBQUtQLE1BQU0sRUFBRSxDQUFDLEdBQ2xDakMsYUFBYSxVQUNiLENBQUMsR0FBRyxFQUFFa0MsYUFBYU8sVUFBVSxLQUFLLE1BQU0sSUFBSSxFQUFFLENBQUMsR0FDL0M7WUFDTlYsT0FBT00sSUFBSSxDQUFDZCxTQUFTZ0IsU0FBU1YsZUFBZUs7WUFDN0NEO1FBQ0Y7SUFDRjtJQUVBLE9BQU9GLE9BQU9XLElBQUksQ0FBQztBQUNyQiJ9

package/dist/field/features/types.d.ts

@@ -0,0 +1,95 @@
+import type { Transformer } from '@lexical/markdown';
+import type { Klass, LexicalEditor, LexicalNode } from 'lexical';
+import type { SerializedLexicalNode } from 'lexical';
+import type { PayloadRequest, RichTextField } from 'payload/types';
+import type React from 'react';
+import type { AdapterProps } from '../../types';
+import type { EditorConfig } from '..//lexical/config/types';
+import type { FloatingToolbarSection } from '../lexical/plugins/FloatingSelectToolbar/types';
+import type { SlashMenuGroup } from '../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu';
+export type AfterReadPromise<T extends SerializedLexicalNode = SerializedLexicalNode> = ({ afterReadPromises, currentDepth, depth, field, node, overrideAccess, req, showHiddenFields, }: {
+    afterReadPromises: Map<string, Array<AfterReadPromise>>;
+    currentDepth: number;
+    depth: number;
+    field: RichTextField<AdapterProps>;
+    node: T;
+    overrideAccess: boolean;
+    req: PayloadRequest;
+    showHiddenFields: boolean;
+}) => Promise<void>[];
+export type Feature = {
+    floatingSelectToolbar?: {
+        sections: FloatingToolbarSection[];
+    };
+    markdownTransformers?: Transformer[];
+    nodes?: Array<{
+        afterReadPromises?: Array<AfterReadPromise>;
+        node: Klass<LexicalNode>;
+        type: string;
+    }>;
+    plugins?: Array<{
+        Component: React.FC;
+        position: 'normal';
+    } | {
+        Component: React.FC<{
+            anchorElem: HTMLElement;
+        }>;
+        position: 'floatingAnchorElem';
+    }>;
+    /** Props which were passed into your feature will have to be passed here. This will allow them to be used / read in other places of the code, e.g. wherever you can use useEditorConfigContext */
+    props: unknown;
+    slashMenu?: {
+        dynamicOptions?: ({ editor, queryString, }: {
+            editor: LexicalEditor;
+            queryString: string;
+        }) => SlashMenuGroup[];
+        options?: SlashMenuGroup[];
+    };
+};
+export type FeatureProvider = {
+    /** Keys of dependencies needed for this feature. These dependencies do not have to be loaded first */
+    dependencies?: string[];
+    /** Keys of priority dependencies needed for this feature. These dependencies have to be loaded first and are available in the `feature` property*/
+    dependenciesPriority?: string[];
+    /** Keys of soft-dependencies needed for this feature. These dependencies are optional, but are considered as last-priority in the loading process */
+    dependenciesSoft?: string[];
+    feature: (props: {
+        /** unsanitizedEditorConfig.features, but mapped */
+        featureProviderMap: FeatureProviderMap;
+        resolvedFeatures: ResolvedFeatureMap;
+        unsanitizedEditorConfig: EditorConfig;
+    }) => Feature;
+    key: string;
+};
+export type ResolvedFeature = Feature & Required<Pick<FeatureProvider, 'dependencies' | 'dependenciesPriority' | 'dependenciesSoft' | 'key'>>;
+export type ResolvedFeatureMap = Map<string, ResolvedFeature>;
+export type FeatureProviderMap = Map<string, FeatureProvider>;
+export type SanitizedFeatures = Required<Pick<ResolvedFeature, 'markdownTransformers' | 'nodes'>> & {
+    /**  The node types mapped to their afterReadPromises */
+    afterReadPromises: Map<string, Array<AfterReadPromise>>;
+    /** The keys of all enabled features */
+    enabledFeatures: string[];
+    floatingSelectToolbar: {
+        sections: FloatingToolbarSection[];
+    };
+    plugins?: Array<{
+        Component: React.FC;
+        key: string;
+        position: 'normal';
+    } | {
+        Component: React.FC<{
+            anchorElem: HTMLElement;
+        }>;
+        desktopOnly?: boolean;
+        key: string;
+        position: 'floatingAnchorElem';
+    }>;
+    slashMenu: {
+        dynamicOptions: Array<({ editor, queryString }: {
+            editor: LexicalEditor;
+            queryString: string;
+        }) => SlashMenuGroup[]>;
+        groupsWithOptions: SlashMenuGroup[];
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/field/features/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/field/features/types.ts"],"names":[],"mappings":"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"}

package/dist/field/features/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/field/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/field/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAyB,MAAM,OAAO,CAAA;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAK1C,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,UAAU,CAI9C,CAAA"}

package/dist/field/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RichTextField", {
+    enumerable: true,
+    get: function() {
+        return RichTextField;
+    }
+});
+const _components = require("payload/components");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+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;
+}
+// @ts-expect-error Just TypeScript being broken // TODO: Open TypeScript issue
+const RichTextEditor = /*#__PURE__*/ (0, _react.lazy)(()=>Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./Field"))));
+const RichTextField = (props)=>/*#__PURE__*/ _react.default.createElement(_react.Suspense, {
+        fallback: /*#__PURE__*/ _react.default.createElement(_components.ShimmerEffect, {
+            height: "35vh"
+        })
+    }, /*#__PURE__*/ _react.default.createElement(RichTextEditor, props));
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maWVsZC9pbmRleC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2hpbW1lckVmZmVjdCB9IGZyb20gJ3BheWxvYWQvY29tcG9uZW50cydcbmltcG9ydCBSZWFjdCwgeyBTdXNwZW5zZSwgbGF6eSB9IGZyb20gJ3JlYWN0J1xuXG5pbXBvcnQgdHlwZSB7IEZpZWxkUHJvcHMgfSBmcm9tICcuLi90eXBlcydcblxuLy8gQHRzLWV4cGVjdC1lcnJvciBKdXN0IFR5cGVTY3JpcHQgYmVpbmcgYnJva2VuIC8vIFRPRE86IE9wZW4gVHlwZVNjcmlwdCBpc3N1ZVxuY29uc3QgUmljaFRleHRFZGl0b3IgPSBsYXp5KCgpID0+IGltcG9ydCgnLi9GaWVsZCcpKVxuXG5leHBvcnQgY29uc3QgUmljaFRleHRGaWVsZDogUmVhY3QuRkM8RmllbGRQcm9wcz4gPSAocHJvcHMpID0+IChcbiAgPFN1c3BlbnNlIGZhbGxiYWNrPXs8U2hpbW1lckVmZmVjdCBoZWlnaHQ9XCIzNXZoXCIgLz59PlxuICAgIDxSaWNoVGV4dEVkaXRvciB7Li4ucHJvcHN9IC8+XG4gIDwvU3VzcGVuc2U+XG4pXG4iXSwibmFtZXMiOlsiUmljaFRleHRGaWVsZCIsIlJpY2hUZXh0RWRpdG9yIiwibGF6eSIsInByb3BzIiwiU3VzcGVuc2UiLCJmYWxsYmFjayIsIlNoaW1tZXJFZmZlY3QiLCJoZWlnaHQiXSwibWFwcGluZ3MiOiI7Ozs7K0JBUWFBOzs7ZUFBQUE7Ozs0QkFSaUI7K0RBQ1E7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFJdEMsK0VBQStFO0FBQy9FLE1BQU1DLCtCQUFpQkMsSUFBQUEsV0FBSSxFQUFDLElBQU0sbUVBQUEsUUFBTztBQUVsQyxNQUFNRixnQkFBc0MsQ0FBQ0csc0JBQ2xELDZCQUFDQyxlQUFRO1FBQUNDLHdCQUFVLDZCQUFDQyx5QkFBYTtZQUFDQyxRQUFPOztxQkFDeEMsNkJBQUNOLGdCQUFtQkUifQ==

package/dist/field/lexical/LexicalEditor.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { LexicalProviderProps } from './LexicalProvider';
+import './LexicalEditor.scss';
+export declare const LexicalEditor: React.FC<LexicalProviderProps>;
+//# sourceMappingURL=LexicalEditor.d.ts.map

package/dist/field/lexical/LexicalEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalEditor.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalEditor.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAE7D,OAAO,sBAAsB,CAAA;AAQ7B,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAmFxD,CAAA"}

package/dist/field/lexical/LexicalEditor.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LexicalEditor", {
+    enumerable: true,
+    get: function() {
+        return LexicalEditor;
+    }
+});
+const _LexicalErrorBoundary = /*#__PURE__*/ _interop_require_default(require("@lexical/react/LexicalErrorBoundary"));
+const _LexicalHistoryPlugin = require("@lexical/react/LexicalHistoryPlugin");
+const _LexicalOnChangePlugin = require("@lexical/react/LexicalOnChangePlugin");
+const _LexicalRichTextPlugin = require("@lexical/react/LexicalRichTextPlugin");
+const _LexicalTabIndentationPlugin = require("@lexical/react/LexicalTabIndentationPlugin");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+require("./LexicalEditor.scss");
+const _FloatingSelectToolbar = require("./plugins/FloatingSelectToolbar");
+const _MarkdownShortcut = require("./plugins/MarkdownShortcut");
+const _SlashMenu = require("./plugins/SlashMenu");
+const _AddBlockHandlePlugin = require("./plugins/handles/AddBlockHandlePlugin");
+const _DraggableBlockPlugin = require("./plugins/handles/DraggableBlockPlugin");
+const _ContentEditable = require("./ui/ContentEditable");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 LexicalEditor = (props)=>{
+    const { editorConfig, onChange } = props;
+    const [floatingAnchorElem, setFloatingAnchorElem] = (0, _react.useState)(null);
+    const onRef = (_floatingAnchorElem)=>{
+        if (_floatingAnchorElem !== null) {
+            setFloatingAnchorElem(_floatingAnchorElem);
+        }
+    };
+    const [isSmallWidthViewport, setIsSmallWidthViewport] = (0, _react.useState)(false);
+    (0, _react.useEffect)(()=>{
+        const updateViewPortWidth = ()=>{
+            const isNextSmallWidthViewport = window.matchMedia('(max-width: 1025px)').matches;
+            if (isNextSmallWidthViewport !== isSmallWidthViewport) {
+                setIsSmallWidthViewport(isNextSmallWidthViewport);
+            }
+        };
+        updateViewPortWidth();
+        window.addEventListener('resize', updateViewPortWidth);
+        return ()=>{
+            window.removeEventListener('resize', updateViewPortWidth);
+        };
+    }, [
+        isSmallWidthViewport
+    ]);
+    return /*#__PURE__*/ _react.createElement(_react.Fragment, null, /*#__PURE__*/ _react.createElement(_LexicalRichTextPlugin.RichTextPlugin, {
+        ErrorBoundary: _LexicalErrorBoundary.default,
+        contentEditable: /*#__PURE__*/ _react.createElement("div", {
+            className: "editor-scroller"
+        }, /*#__PURE__*/ _react.createElement("div", {
+            className: "editor",
+            ref: onRef
+        }, /*#__PURE__*/ _react.createElement(_ContentEditable.LexicalContentEditable, null))),
+        placeholder: /*#__PURE__*/ _react.createElement("p", {
+            className: "editor-placeholder"
+        }, "Start typing...")
+    }), /*#__PURE__*/ _react.createElement(_LexicalOnChangePlugin.OnChangePlugin, {
+        // Selection changes can be ignore here, reducing the
+        // frequency that the FieldComponent and Payload receive updates.
+        // Selection changes are only needed if you are saving selection state
+        ignoreSelectionChange: true,
+        onChange: (editorState, editor, tags)=>{
+            // Ignore any onChange event triggered by focus only
+            if (!tags.has('focus') || tags.size > 1) {
+                if (onChange != null) onChange(editorState, editor, tags);
+            }
+        }
+    }), floatingAnchorElem && /*#__PURE__*/ _react.createElement(_react.Fragment, null, !isSmallWidthViewport && /*#__PURE__*/ _react.createElement(_react.Fragment, null, /*#__PURE__*/ _react.createElement(_DraggableBlockPlugin.DraggableBlockPlugin, {
+        anchorElem: floatingAnchorElem
+    }), /*#__PURE__*/ _react.createElement(_AddBlockHandlePlugin.AddBlockHandlePlugin, {
+        anchorElem: floatingAnchorElem
+    })), editorConfig.features.plugins.map((plugin)=>{
+        if (plugin.position === 'floatingAnchorElem' && !(plugin.desktopOnly === true && isSmallWidthViewport)) {
+            return /*#__PURE__*/ _react.createElement(plugin.Component, {
+                anchorElem: floatingAnchorElem,
+                key: plugin.key
+            });
+        }
+    })), /*#__PURE__*/ _react.createElement(_LexicalHistoryPlugin.HistoryPlugin, null), /*#__PURE__*/ _react.createElement(_FloatingSelectToolbar.FloatingSelectToolbarPlugin, null), /*#__PURE__*/ _react.createElement(_SlashMenu.SlashMenuPlugin, null), /*#__PURE__*/ _react.createElement(_LexicalTabIndentationPlugin.TabIndentationPlugin, null), editorConfig.features.plugins.map((plugin)=>{
+        if (plugin.position === 'normal') {
+            return /*#__PURE__*/ _react.createElement(plugin.Component, {
+                key: plugin.key
+            });
+        }
+    }), /*#__PURE__*/ _react.createElement(_MarkdownShortcut.MarkdownShortcutPlugin, null));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/field/lexical/LexicalEditor.tsx"],"sourcesContent":["import LexicalErrorBoundary from '@lexical/react/LexicalErrorBoundary'\nimport { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin'\nimport { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin'\nimport { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin'\nimport { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\n\nimport type { LexicalProviderProps } from './LexicalProvider'\n\nimport './LexicalEditor.scss'\nimport { FloatingSelectToolbarPlugin } from './plugins/FloatingSelectToolbar'\nimport { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut'\nimport { SlashMenuPlugin } from './plugins/SlashMenu'\nimport { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin'\nimport { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin'\nimport { LexicalContentEditable } from './ui/ContentEditable'\n\nexport const LexicalEditor: React.FC<LexicalProviderProps> = (props) => {\n  const { editorConfig, onChange } = props\n\n  const [floatingAnchorElem, setFloatingAnchorElem] = useState<HTMLDivElement | null>(null)\n  const onRef = (_floatingAnchorElem: HTMLDivElement) => {\n    if (_floatingAnchorElem !== null) {\n      setFloatingAnchorElem(_floatingAnchorElem)\n    }\n  }\n\n  const [isSmallWidthViewport, setIsSmallWidthViewport] = useState<boolean>(false)\n\n  useEffect(() => {\n    const updateViewPortWidth = () => {\n      const isNextSmallWidthViewport = window.matchMedia('(max-width: 1025px)').matches\n\n      if (isNextSmallWidthViewport !== isSmallWidthViewport) {\n        setIsSmallWidthViewport(isNextSmallWidthViewport)\n      }\n    }\n    updateViewPortWidth()\n    window.addEventListener('resize', updateViewPortWidth)\n\n    return () => {\n      window.removeEventListener('resize', updateViewPortWidth)\n    }\n  }, [isSmallWidthViewport])\n\n  return (\n    <React.Fragment>\n      <RichTextPlugin\n        ErrorBoundary={LexicalErrorBoundary}\n        contentEditable={\n          <div className=\"editor-scroller\">\n            <div className=\"editor\" ref={onRef}>\n              <LexicalContentEditable />\n            </div>\n          </div>\n        }\n        placeholder={<p className=\"editor-placeholder\">Start typing...</p>}\n      />\n      <OnChangePlugin\n        // Selection changes can be ignore here, reducing the\n        // frequency that the FieldComponent and Payload receive updates.\n        // Selection changes are only needed if you are saving selection state\n        ignoreSelectionChange\n        onChange={(editorState, editor, tags) => {\n          // Ignore any onChange event triggered by focus only\n          if (!tags.has('focus') || tags.size > 1) {\n            if (onChange != null) onChange(editorState, editor, tags)\n          }\n        }}\n      />\n      {floatingAnchorElem && (\n        <React.Fragment>\n          {!isSmallWidthViewport && (\n            <React.Fragment>\n              <DraggableBlockPlugin anchorElem={floatingAnchorElem} />\n              <AddBlockHandlePlugin anchorElem={floatingAnchorElem} />\n            </React.Fragment>\n          )}\n          {editorConfig.features.plugins.map((plugin) => {\n            if (\n              plugin.position === 'floatingAnchorElem' &&\n              !(plugin.desktopOnly === true && isSmallWidthViewport)\n            ) {\n              return <plugin.Component anchorElem={floatingAnchorElem} key={plugin.key} />\n            }\n          })}\n        </React.Fragment>\n      )}\n      <HistoryPlugin />\n      <FloatingSelectToolbarPlugin />\n      <SlashMenuPlugin />\n      <TabIndentationPlugin />\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'normal') {\n          return <plugin.Component key={plugin.key} />\n        }\n      })}\n      <MarkdownShortcutPlugin />\n    </React.Fragment>\n  )\n}\n"],"names":["LexicalEditor","props","editorConfig","onChange","floatingAnchorElem","setFloatingAnchorElem","useState","onRef","_floatingAnchorElem","isSmallWidthViewport","setIsSmallWidthViewport","useEffect","updateViewPortWidth","isNextSmallWidthViewport","window","matchMedia","matches","addEventListener","removeEventListener","React","Fragment","RichTextPlugin","ErrorBoundary","LexicalErrorBoundary","contentEditable","div","className","ref","LexicalContentEditable","placeholder","p","OnChangePlugin","ignoreSelectionChange","editorState","editor","tags","has","size","DraggableBlockPlugin","anchorElem","AddBlockHandlePlugin","features","plugins","map","plugin","position","desktopOnly","Component","key","HistoryPlugin","FloatingSelectToolbarPlugin","SlashMenuPlugin","TabIndentationPlugin","MarkdownShortcutPlugin"],"mappings":";;;;+BAkBaA;;;eAAAA;;;6EAlBoB;sCACH;uCACC;uCACA;6CACM;+DACd;QAKhB;uCACqC;kCACL;2BACP;sCACK;sCACA;iCACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhC,MAAMA,gBAAgD,CAACC;IAC5D,MAAM,EAAEC,YAAY,EAAEC,QAAQ,EAAE,GAAGF;IAEnC,MAAM,CAACG,oBAAoBC,sBAAsB,GAAGC,IAAAA,eAAQ,EAAwB;IACpF,MAAMC,QAAQ,CAACC;QACb,IAAIA,wBAAwB,MAAM;YAChCH,sBAAsBG;QACxB;IACF;IAEA,MAAM,CAACC,sBAAsBC,wBAAwB,GAAGJ,IAAAA,eAAQ,EAAU;IAE1EK,IAAAA,gBAAS,EAAC;QACR,MAAMC,sBAAsB;YAC1B,MAAMC,2BAA2BC,OAAOC,UAAU,CAAC,uBAAuBC,OAAO;YAEjF,IAAIH,6BAA6BJ,sBAAsB;gBACrDC,wBAAwBG;YAC1B;QACF;QACAD;QACAE,OAAOG,gBAAgB,CAAC,UAAUL;QAElC,OAAO;YACLE,OAAOI,mBAAmB,CAAC,UAAUN;QACvC;IACF,GAAG;QAACH;KAAqB;IAEzB,qBACE,qBAACU,OAAMC,QAAQ,sBACb,qBAACC,qCAAc;QACbC,eAAeC,6BAAoB;QACnCC,+BACE,qBAACC;YAAIC,WAAU;yBACb,qBAACD;YAAIC,WAAU;YAASC,KAAKpB;yBAC3B,qBAACqB,uCAAsB;QAI7BC,2BAAa,qBAACC;YAAEJ,WAAU;WAAqB;sBAEjD,qBAACK,qCAAc;QACb,qDAAqD;QACrD,iEAAiE;QACjE,sEAAsE;QACtEC,uBAAAA;QACA7B,UAAU,CAAC8B,aAAaC,QAAQC;YAC9B,oDAAoD;YACpD,IAAI,CAACA,KAAKC,GAAG,CAAC,YAAYD,KAAKE,IAAI,GAAG,GAAG;gBACvC,IAAIlC,YAAY,MAAMA,SAAS8B,aAAaC,QAAQC;YACtD;QACF;QAED/B,oCACC,qBAACe,OAAMC,QAAQ,QACZ,CAACX,sCACA,qBAACU,OAAMC,QAAQ,sBACb,qBAACkB,0CAAoB;QAACC,YAAYnC;sBAClC,qBAACoC,0CAAoB;QAACD,YAAYnC;SAGrCF,aAAauC,QAAQ,CAACC,OAAO,CAACC,GAAG,CAAC,CAACC;QAClC,IACEA,OAAOC,QAAQ,KAAK,wBACpB,CAAED,CAAAA,OAAOE,WAAW,KAAK,QAAQrC,oBAAmB,GACpD;YACA,qBAAO,qBAACmC,OAAOG,SAAS;gBAACR,YAAYnC;gBAAoB4C,KAAKJ,OAAOI,GAAG;;QAC1E;IACF,mBAGJ,qBAACC,mCAAa,uBACd,qBAACC,kDAA2B,uBAC5B,qBAACC,0BAAe,uBAChB,qBAACC,iDAAoB,SACpBlD,aAAauC,QAAQ,CAACC,OAAO,CAACC,GAAG,CAAC,CAACC;QAClC,IAAIA,OAAOC,QAAQ,KAAK,UAAU;YAChC,qBAAO,qBAACD,OAAOG,SAAS;gBAACC,KAAKJ,OAAOI,GAAG;;QAC1C;IACF,kBACA,qBAACK,wCAAsB;AAG7B"}

package/dist/field/lexical/LexicalProvider.d.ts

@@ -0,0 +1,16 @@
+import type { EditorState, SerializedEditorState } from 'lexical';
+import type { LexicalEditor } from 'lexical';
+import * as React from 'react';
+import type { FieldProps } from '../../types';
+import type { SanitizedEditorConfig } from './config/types';
+export type LexicalProviderProps = {
+    editorConfig: SanitizedEditorConfig;
+    fieldProps: FieldProps;
+    initialState: SerializedEditorState;
+    onChange: (editorState: EditorState, editor: LexicalEditor, tags: Set<string>) => void;
+    readOnly: boolean;
+    setValue: (value: SerializedEditorState) => void;
+    value: SerializedEditorState;
+};
+export declare const LexicalProvider: React.FC<LexicalProviderProps>;
+//# sourceMappingURL=LexicalProvider.d.ts.map

package/dist/field/lexical/LexicalProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalProvider.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalProvider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAG5C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAK3D,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,qBAAqB,CAAA;IACnC,UAAU,EAAE,UAAU,CAAA;IACtB,YAAY,EAAE,qBAAqB,CAAA;IACnC,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAA;IACtF,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAA;IAChD,KAAK,EAAE,qBAAqB,CAAA;CAC7B,CAAA;AACD,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA+B1D,CAAA"}