@lobehub/editor 4.15.1 → 4.16.0

package/es/plugins/codemirror-block/plugin/index.js

@@ -0,0 +1,80 @@
+import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js";
+import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
+import { ILitexmlService } from "../../litexml/service/litexml-service.js";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut.js";
+import { $createCodeMirrorNode, CodeMirrorNode } from "../node/CodeMirrorNode.js";
+import { registerCodeMirrorCommand } from "../command/index.js";
+import { modeMatch } from "../lib/mode.js";
+import { $createNodeSelection, $setSelection } from "lexical";
+//#region src/plugins/codemirror-block/plugin/index.ts
+init_helper();
+init_plugin();
+const CodemirrorPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "CodemirrorPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		kernel.registerNodes([CodeMirrorNode]);
+		kernel.registerThemes({ hr: config?.theme || "" });
+		this.registerDecorator(kernel, "codemirror", (node, editor) => {
+			return config?.decorator ? config.decorator(node, editor) : null;
+		});
+	}
+	onInit(editor) {
+		this.register(registerCodeMirrorCommand(editor));
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(CodeMirrorNode.getType(), (node, ctx) => {
+			const codeMirrorNode = node;
+			return ctx.createXmlNode("code", { lang: codeMirrorNode.lang || "plain" }, codeMirrorNode.code);
+		});
+		litexmlService.registerXMLReader("code", (xmlElement, children) => {
+			const text = children.map((v) => v.text || "").join("");
+			const language = xmlElement.getAttribute("lang") || "plain";
+			return INodeHelper.createTypeNode("code", {
+				code: text || xmlElement.textContent || "",
+				language: modeMatch(language),
+				version: 1
+			});
+		});
+	}
+	registerMarkdown() {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		markdownService?.registerMarkdownShortCut({
+			regExp: /^(```|···)(.+)?$/,
+			replace: (parentNode, _, match) => {
+				const code = $createCodeMirrorNode(modeMatch(match[2]), "");
+				parentNode.replace(code);
+				const sel = $createNodeSelection();
+				sel.add(code.getKey());
+				$setSelection(sel);
+			},
+			trigger: "enter",
+			type: "element"
+		});
+		markdownService?.registerMarkdownWriter(CodeMirrorNode.getType(), (ctx, node) => {
+			if (node instanceof CodeMirrorNode) {
+				ctx.appendLine("```" + node.lang);
+				ctx.appendLine("\n");
+				ctx.appendLine(node.code);
+				ctx.appendLine("\n```\n");
+			}
+		});
+		markdownService?.registerMarkdownReader("code", (node) => {
+			const language = node.lang ? modeMatch(node.lang) : "plain";
+			return INodeHelper.createTypeNode("code", {
+				code: node.value,
+				language,
+				version: 1
+			});
+		});
+	}
+};
+//#endregion
+export { CodemirrorPlugin };

package/es/plugins/codemirror-block/react/CodemirrorNode.js

@@ -0,0 +1,219 @@
+"use client";
+import { Toolbar } from "../../../codemirror/components/Toolbar.js";
+import { loadCodeMirror } from "../../../codemirror/loader.js";
+import { styles } from "../../../codemirror/style.js";
+import { lobeTheme } from "../../../codemirror/theme.js";
+import { useTranslation } from "../../../editor-kernel/react/useTranslation.js";
+import { SELECT_AFTER_CODEMIRROR_COMMAND, SELECT_BEFORE_CODEMIRROR_COMMAND } from "../command/index.js";
+import { useLexicalNodeSelection } from "../../../editor-kernel/react/useLexicalNodeSelection.js";
+import { Block } from "@lobehub/ui";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cx } from "antd-style";
+import { debounce } from "es-toolkit/compat";
+import { $getSelection, $setSelection, COMMAND_PRIORITY_CRITICAL, KEY_DOWN_COMMAND } from "lexical";
+import { mergeRegister } from "@lexical/utils";
+//#region src/plugins/codemirror-block/react/CodemirrorNode.tsx
+const ReactCodemirrorNode = ({ node, className, editor }) => {
+	const ref = useRef(null);
+	const keydownRef = useRef("");
+	const instanceRef = useRef(null);
+	const isEmptyRef = useRef(false);
+	const t = useTranslation();
+	const [isSelected, setSelected, clearSelection, isNodeSelected] = useLexicalNodeSelection(node.getKey());
+	const [selectedLang, setSelectedLang] = useState(node.lang || "javascript");
+	const [tabSize, setTabSize] = useState(node.options.tabSize ?? 2);
+	const [useTabs, setUseTabs] = useState(node.options.indentWithTabs ?? false);
+	const [showLineNumbers, setShowLineNumbers] = useState(node.options.lineNumbers ?? false);
+	const [expand, setExpand] = useState(true);
+	const handleCopy = useCallback(async () => {
+		if (instanceRef.current) {
+			const code = instanceRef.current.getValue();
+			try {
+				await navigator.clipboard.writeText(code);
+			} catch {}
+		}
+	}, []);
+	const labels = useMemo(() => ({
+		selectLanguage: t("codemirror.selectLanguage"),
+		showLineNumbers: t("codemirror.showLineNumbers"),
+		tabSize: t("codemirror.tabSize"),
+		useTabs: t("codemirror.useTabs")
+	}), [t]);
+	const handleLanguageChange = useCallback((value) => {
+		setSelectedLang(value);
+		if (instanceRef.current) instanceRef.current.setOption("mode", value);
+		editor.update(() => {
+			node.setLang(value);
+		});
+	}, [editor, node]);
+	const handleTabSizeChange = useCallback((value = 2) => {
+		const v = value === null ? 2 : value;
+		setTabSize(v);
+		if (instanceRef.current) instanceRef.current.setOption("tabSize", v);
+		editor.update(() => {
+			node.setTabSize(v);
+		});
+	}, [editor, node]);
+	const handleUseTabsChange = useCallback((checked) => {
+		setUseTabs(checked);
+		if (instanceRef.current) instanceRef.current.setOption("indentWithTabs", checked);
+		editor.update(() => {
+			node.setIndentWithTabs(checked);
+		});
+	}, [editor, node]);
+	const handleShowLineNumbersChange = useCallback((checked) => {
+		setShowLineNumbers(checked);
+		if (instanceRef.current) instanceRef.current.setOption("lineNumbers", checked);
+		editor.update(() => {
+			node.setLineNumbers(checked);
+		});
+	}, [editor, node]);
+	useEffect(() => {
+		const sel = editor.getEditorState().read(() => $getSelection());
+		if (instanceRef.current?.view.hasFocus && sel === null) return;
+		if (!isSelected || !isNodeSelected) {
+			if (instanceRef.current) instanceRef.current.blur();
+			return;
+		}
+		if (isSelected && instanceRef.current && isNodeSelected) {
+			if (instanceRef.current?.view.hasFocus) return;
+			instanceRef.current.focus();
+			if (keydownRef.current === "end") instanceRef.current.setSelectionToEnd();
+		}
+	}, [
+		isSelected,
+		isNodeSelected,
+		editor
+	]);
+	useEffect(() => {
+		if (instanceRef.current) return;
+		if (ref.current) {
+			const dom = ref.current;
+			loadCodeMirror().then((CodeMirror) => {
+				if (instanceRef.current) return;
+				const instance = CodeMirror.fromTextArea(dom, {
+					indentWithTabs: useTabs,
+					lineNumbers: showLineNumbers,
+					mode: node.lang,
+					tabSize,
+					theme: "default",
+					value: node.code
+				});
+				console.info(instance);
+				instance.view.dispatch({ effects: instance.optionHelper.theme.reconfigure(instance.view.constructor.theme(lobeTheme, { dark: false })) });
+				isEmptyRef.current = !node.code.trim();
+				instance.on("keydown", (instance, e) => {
+					e.stopPropagation();
+					if ((e.key === "Enter" || e.keyCode === 13) && (e.metaKey || e.ctrlKey)) {
+						e.preventDefault();
+						instanceRef.current?.blur();
+						editor.dispatchCommand(SELECT_AFTER_CODEMIRROR_COMMAND, { key: node.getKey() });
+						queueMicrotask(() => {
+							editor.focus();
+						});
+						return;
+					}
+					if (e.key === "Backspace" || e.keyCode === 8) {
+						if (!isEmptyRef.current) return;
+						e.preventDefault();
+						editor.update(() => {
+							const prevNode = node.getPreviousSibling();
+							node.remove();
+							if (prevNode) {
+								const prevSelection = prevNode.selectEnd();
+								if (prevSelection) $setSelection(prevSelection);
+							}
+						});
+						queueMicrotask(() => {
+							editor.focus();
+						});
+					}
+				});
+				instance.on("leftOut", () => {
+					instanceRef.current?.blur();
+					editor.dispatchCommand(SELECT_BEFORE_CODEMIRROR_COMMAND, { key: node.getKey() });
+					queueMicrotask(() => {
+						editor.focus();
+					});
+				});
+				instance.on("rightOut", () => {
+					instanceRef.current?.blur();
+					editor.dispatchCommand(SELECT_AFTER_CODEMIRROR_COMMAND, { key: node.getKey() });
+					queueMicrotask(() => {
+						editor.focus();
+					});
+				});
+				instance.on("change", () => {
+					isEmptyRef.current = !instance.getValue().trim();
+				});
+				instance.on("change", debounce(() => {
+					const currentValue = instance.getValue();
+					editor.update(() => {
+						node.setCode(currentValue);
+					});
+				}));
+				instance.on("focus", () => {
+					if (editor.getEditorState().read(() => {
+						const sel = $getSelection();
+						if (!sel) return false;
+						if (sel?.getNodes().length > 1 || !sel?.getNodes().includes(node)) return true;
+						return false;
+					})) setSelected(true);
+				});
+				instanceRef.current = instance;
+				if (isSelected) instanceRef.current.focus();
+			});
+		}
+		return () => {
+			if (instanceRef.current) {
+				instanceRef.current.destroy();
+				instanceRef.current = null;
+			}
+		};
+	}, [ref]);
+	useEffect(() => {
+		return mergeRegister(editor.registerCommand(KEY_DOWN_COMMAND, (payload) => {
+			if (payload.key === "ArrowLeft" || payload.key === "ArrowUp") keydownRef.current = "end";
+			else keydownRef.current = "";
+			return false;
+		}, COMMAND_PRIORITY_CRITICAL));
+	}, [
+		clearSelection,
+		editor,
+		isSelected,
+		node,
+		setSelected
+	]);
+	return /* @__PURE__ */ jsxs(Block, {
+		className: cx(styles, isSelected && !isNodeSelected && "selected", className),
+		onMouseDown: (e) => e.stopPropagation(),
+		onMouseUp: (e) => e.stopPropagation(),
+		onSelect: (e) => e.stopPropagation(),
+		variant: "filled",
+		children: [/* @__PURE__ */ jsx(Toolbar, {
+			expand,
+			labels,
+			onClick: () => setExpand(!expand),
+			onCopy: handleCopy,
+			onLanguageChange: handleLanguageChange,
+			onShowLineNumbersChange: handleShowLineNumbersChange,
+			onTabSizeChange: handleTabSizeChange,
+			onUseTabsChange: handleUseTabsChange,
+			selectedLang,
+			showLineNumbers,
+			tabSize,
+			toggleExpand: () => setExpand(!expand),
+			useTabs
+		}), /* @__PURE__ */ jsx("div", {
+			className: cx("cm-container", !expand && "cm-container-collapsed"),
+			children: /* @__PURE__ */ jsx("textarea", {
+				className: "cm-textarea",
+				ref
+			})
+		})]
+	});
+};
+ReactCodemirrorNode.displayName = "ReactCodemirrorNode";
+//#endregion
+export { ReactCodemirrorNode as default };

package/es/plugins/codemirror-block/react/ReactCodemirrorNode.d.ts

@@ -0,0 +1,7 @@
+import { ReactCodemirrorPluginProps } from "./type.js";
+import { FC } from "react";
+
+//#region src/plugins/codemirror-block/react/ReactCodemirrorNode.d.ts
+declare const ReactCodemirrorPlugin: FC<ReactCodemirrorPluginProps>;
+//#endregion
+export { ReactCodemirrorPlugin };

package/es/plugins/codemirror-block/react/ReactCodemirrorNode.js

@@ -0,0 +1,26 @@
+"use client";
+import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context.js";
+import { CodemirrorPlugin } from "../plugin/index.js";
+import ReactCodemirrorNode from "./CodemirrorNode.js";
+import { useLayoutEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/plugins/codemirror-block/react/ReactCodemirrorNode.tsx
+const ReactCodemirrorPlugin = ({ className }) => {
+	const [editor] = useLexicalComposerContext();
+	useLayoutEffect(() => {
+		editor.registerPlugin(CodemirrorPlugin, {
+			decorator(node, editor) {
+				return /* @__PURE__ */ jsx(ReactCodemirrorNode, {
+					className,
+					editor,
+					node
+				});
+			},
+			theme: className
+		});
+	}, [editor, className]);
+	return null;
+};
+ReactCodemirrorPlugin.displayName = "ReactCodemirrorPlugin";
+//#endregion
+export { ReactCodemirrorPlugin as default };

package/es/plugins/codemirror-block/react/index.d.ts

@@ -0,0 +1 @@
+import { ReactCodemirrorPlugin } from "./ReactCodemirrorNode.js";

package/es/plugins/codemirror-block/react/type.d.ts

@@ -0,0 +1,6 @@
+//#region src/plugins/codemirror-block/react/type.d.ts
+interface ReactCodemirrorPluginProps {
+  className?: string;
+}
+//#endregion
+export { ReactCodemirrorPluginProps };

package/es/plugins/common/command/index.d.ts

@@ -0,0 +1,11 @@
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+import { HeadingTagType } from "@lexical/rich-text";
+
+//#region src/plugins/common/command/index.d.ts
+declare const INSERT_QUOTE_COMMAND: _$lexical.LexicalCommand<unknown>;
+declare const INSERT_HEADING_COMMAND: _$lexical.LexicalCommand<{
+  tag: HeadingTagType;
+}>;
+//#endregion
+export { INSERT_HEADING_COMMAND, INSERT_QUOTE_COMMAND };

package/es/plugins/common/command/index.js

@@ -0,0 +1,24 @@
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+import { $createHeadingNode, $createQuoteNode } from "@lexical/rich-text";
+import { mergeRegister } from "@lexical/utils";
+import { $setBlocksType } from "@lexical/selection";
+//#region src/plugins/common/command/index.ts
+const INSERT_QUOTE_COMMAND = createCommand("INSERT_QUOTE_COMMAND");
+const INSERT_HEADING_COMMAND = createCommand("INSERT_HEADING_COMMAND");
+function registerCommands(editor) {
+	return mergeRegister(editor.registerCommand(INSERT_QUOTE_COMMAND, () => {
+		editor.update(() => {
+			const selection = $getSelection();
+			if ($isRangeSelection(selection)) $setBlocksType(selection, () => $createQuoteNode());
+		});
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(INSERT_HEADING_COMMAND, (payload) => {
+		editor.update(() => {
+			const selection = $getSelection();
+			if ($isRangeSelection(selection)) $setBlocksType(selection, () => $createHeadingNode(payload.tag));
+		});
+		return true;
+	}, COMMAND_PRIORITY_EDITOR));
+}
+//#endregion
+export { INSERT_HEADING_COMMAND, INSERT_QUOTE_COMMAND, registerCommands };

package/es/plugins/common/data-source/json-data-source.js

@@ -0,0 +1,133 @@
+import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js";
+import { exportNodeToJSON, init_utils } from "../utils/index.js";
+import DataSource from "../../../editor-kernel/data-source.js";
+import { cursorNodeSerialized } from "../node/cursor.js";
+import { $parseSerializedNodeImpl } from "../../litexml/utils/index.js";
+import { $isTableSelection } from "@lexical/table";
+import { $getCharacterOffsets, $getNodeByKey, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $isTextNode, IS_CODE, resetRandomKey } from "lexical";
+//#region src/plugins/common/data-source/json-data-source.ts
+init_helper();
+init_utils();
+var JSONDataSource = class extends DataSource {
+	read(editor, data, options = {}) {
+		let dataObj;
+		if (typeof data === "string") dataObj = JSON.parse(data);
+		else dataObj = data;
+		const process = (node) => {
+			for (let i = 0; i < node.children.length; i++) {
+				const child = node.children[i];
+				if ("children" in child && Array.isArray(child.children)) process(child);
+				if (child.type === "text" && "format" in child && typeof child.format === "number" && (child.format & IS_CODE) > 0) {
+					node.children[i] = {
+						children: [{
+							...child,
+							format: child.format & ~IS_CODE
+						}],
+						direction: "ltr",
+						format: "",
+						indent: 0,
+						type: "codeInline",
+						version: 1
+					};
+					node.children.splice(i + 1, 0, cursorNodeSerialized);
+				}
+			}
+		};
+		process(dataObj.root);
+		if (dataObj.keepId || options.keepId) {
+			const state = editor.parseEditorState({ root: INodeHelper.createRootNode() }, (state) => {
+				try {
+					const root = $parseSerializedNodeImpl(dataObj.root, editor, true, state);
+					let maxId = -1;
+					Array.from(state._nodeMap.keys()).forEach((key) => {
+						if (key === "root") return;
+						const numericKey = Number(key);
+						if (Number.isInteger(numericKey) && numericKey >= 0) maxId = Math.max(maxId, numericKey);
+					});
+					resetRandomKey(maxId + 1);
+					state._nodeMap.set(root.getKey(), root);
+				} catch (error) {
+					console.error(error);
+				}
+			});
+			editor.setEditorState(state);
+		} else editor.setEditorState(editor.parseEditorState({ root: dataObj.root }));
+	}
+	write(editor, options) {
+		if (options?.selection) return editor.getEditorState().read(() => {
+			const selection = $getSelection();
+			if (!selection) return null;
+			if ($isRangeSelection(selection)) {
+				const selectedNodes = selection.getNodes();
+				const lastIndex = selectedNodes.length - 1;
+				const anchor = selection.anchor;
+				const focus = selection.focus;
+				const isBefore = anchor.isBefore(focus);
+				const firstNode = selectedNodes[0];
+				const lastNode = selectedNodes[lastIndex];
+				const [anchorOffset, focusOffset] = $getCharacterOffsets(selection);
+				let lastElement = [];
+				const rootNodes = [];
+				for (let i = 0; i < selectedNodes.length; i++) {
+					const node = selectedNodes[i];
+					if ($isElementNode(node)) {
+						const sNode = {
+							...node.exportJSON(),
+							$key: node.getKey()
+						};
+						for (let i = 0; i < rootNodes.length; i++) {
+							const child = rootNodes[i];
+							const childNode = $getNodeByKey(child.$key);
+							if (node.isParentOf(childNode)) {
+								sNode.children.push(child);
+								rootNodes.splice(i, 1);
+								i--;
+							}
+						}
+						let hasPush = false;
+						for (let i = lastElement.length - 1; i >= 0; i--) if ($getNodeByKey(lastElement[i].$key)?.isParentOf(node)) {
+							lastElement[i].children.push(sNode);
+							hasPush = true;
+							break;
+						} else lastElement.pop();
+						if (!hasPush) rootNodes.push(sNode);
+						lastElement.push(sNode);
+					} else if ($isTextNode(node)) {
+						const sNode = {
+							...node.exportJSON(),
+							$key: node.getKey()
+						};
+						if (node === firstNode) if (node === lastNode) {
+							if (anchor.type !== "element" || focus.type !== "element" || focus.offset === anchor.offset) sNode.text = anchorOffset < focusOffset ? sNode.text.slice(anchorOffset, focusOffset) : sNode.text.slice(focusOffset, anchorOffset);
+						} else sNode.text = isBefore ? sNode.text.slice(anchorOffset) : sNode.text.slice(focusOffset);
+						else if (node === lastNode) sNode.text = isBefore ? sNode.text.slice(0, focusOffset) : sNode.text.slice(0, anchorOffset);
+						let hasPush = false;
+						for (let i = lastElement.length - 1; i >= 0; i--) if ($getNodeByKey(lastElement[i].$key)?.isParentOf(node)) {
+							lastElement[i].children.push(sNode);
+							hasPush = true;
+							break;
+						} else lastElement.pop();
+						if (!hasPush) rootNodes.push(sNode);
+					} else {
+						const sNode = {
+							...node.exportJSON(),
+							$key: node.getKey()
+						};
+						let hasPush = false;
+						for (let i = lastElement.length - 1; i >= 0; i--) if ($getNodeByKey(lastElement[i].$key)?.isParentOf(node)) {
+							lastElement[i].children.push(sNode);
+							hasPush = true;
+							break;
+						} else lastElement.pop();
+						if (!hasPush) rootNodes.push(sNode);
+					}
+				}
+				return rootNodes;
+			} else if ($isTableSelection(selection)) {}
+			return selection.getNodes().map((node) => exportNodeToJSON(node));
+		});
+		return editor.read(() => ({ root: exportNodeToJSON($getRoot()) }));
+	}
+};
+//#endregion
+export { JSONDataSource as default };

package/es/plugins/common/data-source/text-data-source.js

@@ -0,0 +1,32 @@
+import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js";
+import DataSource from "../../../editor-kernel/data-source.js";
+import { $getRoot, $getSelection } from "lexical";
+//#region src/plugins/common/data-source/text-data-source.ts
+init_helper();
+var TextDataSource = class extends DataSource {
+	read(editor, data) {
+		if (typeof data !== "string") throw new Error("Invalid data type " + typeof data);
+		const lines = data.split(/\n/g);
+		const rootNode = INodeHelper.createRootNode();
+		lines.forEach((line) => {
+			const paragraph = INodeHelper.createParagraph();
+			if (line) {
+				const textNode = INodeHelper.createTextNode(line);
+				INodeHelper.appendChild(paragraph, textNode);
+			}
+			INodeHelper.appendChild(rootNode, paragraph);
+		});
+		editor.setEditorState(editor.parseEditorState({ root: rootNode }));
+	}
+	write(editor, options) {
+		if (options?.selection) return editor.getEditorState().read(() => {
+			const selection = $getSelection();
+			return selection ? selection.getTextContent().replaceAll("", "") : null;
+		});
+		return editor.getEditorState().read(() => {
+			return $getRoot().getTextContent().replaceAll("", "");
+		});
+	}
+};
+//#endregion
+export { TextDataSource as default };

package/es/plugins/common/index.d.ts

@@ -0,0 +1,6 @@
+import { INSERT_HEADING_COMMAND, INSERT_QUOTE_COMMAND } from "./command/index.js";
+import { $createCursorNode, $isCardLikeElementNode, $isCursorNode, CardLikeElementNode, cursorNodeSerialized } from "./node/cursor.js";
+import { CommonPlugin, CommonPluginOptions } from "./plugin/index.js";
+import { ReactEditorContentProps, ReactPlainTextProps } from "./react/type.js";
+import { ReactEditorContent } from "./react/ReactEditorContent.js";
+import { ReactPlainText } from "./react/ReactPlainText.js";

package/es/plugins/common/node/ElementDOMSlot.js

@@ -0,0 +1,30 @@
+import { $getNodeFromDOMNode, init_utils } from "../../../editor-kernel/utils.js";
+import { COMMAND_PRIORITY_HIGH, SELECTION_CHANGE_COMMAND } from "lexical";
+import { CAN_USE_DOM, mergeRegister } from "@lexical/utils";
+//#region src/plugins/common/node/ElementDOMSlot.ts
+init_utils();
+function getElement(node) {
+	if (node.nodeType === Node.ELEMENT_NODE) return node;
+	return node.parentElement;
+}
+function registerBreakLineClick(editor) {
+	return mergeRegister(editor.registerCommand(SELECTION_CHANGE_COMMAND, () => {
+		if (CAN_USE_DOM) {
+			const sel = document.getSelection();
+			if (sel?.anchorNode) {
+				const node = getElement(sel.anchorNode);
+				if (node?.hasAttribute("data-lexical-linebreak") && node.parentElement) {
+					const p = node.parentElement;
+					editor.update(() => {
+						const elem = $getNodeFromDOMNode(p, editor);
+						if (elem) elem.selectEnd();
+					});
+					return true;
+				}
+			}
+		}
+		return false;
+	}, COMMAND_PRIORITY_HIGH));
+}
+//#endregion
+export { registerBreakLineClick };

package/es/plugins/common/node/cursor.d.ts

@@ -0,0 +1,16 @@
+import { ElementNode, LexicalEditor, LexicalNode, SerializedLexicalNode, TextNode } from "lexical";
+
+//#region src/plugins/common/node/cursor.d.ts
+declare class CardLikeElementNode extends ElementNode {
+  isCardLike(): boolean;
+}
+declare const cursorNodeSerialized: SerializedLexicalNode;
+declare class CursorNode extends TextNode {
+  static getType(): string;
+  isUnmergeable(): boolean;
+}
+declare function $createCursorNode(): CursorNode;
+declare function $isCardLikeElementNode(node: LexicalNode | null | undefined): node is CardLikeElementNode;
+declare function $isCursorNode(node: LexicalNode | null | undefined): node is CursorNode;
+//#endregion
+export { $createCursorNode, $isCardLikeElementNode, $isCursorNode, CardLikeElementNode, cursorNodeSerialized };