@lobehub/editor 4.15.1 → 4.15.2

package/es/plugins/link-highlight/plugin/index.js

@@ -0,0 +1,109 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js";
+import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
+import { IMarkdownShortCutService } from "../../markdown/service/shortcut.js";
+import { isValidUrl } from "../../../utils/url.js";
+import { $createLinkHighlightNode, LinkHighlightNode } from "../node/link-highlight.js";
+import { registerLinkHighlightCommand } from "../command/index.js";
+import { registerLinkHighlight } from "./registry.js";
+import { $createTextNode, $getSelection, $isRangeSelection, COMMAND_PRIORITY_NORMAL, PASTE_COMMAND } from "lexical";
+//#region src/plugins/link-highlight/plugin/index.ts
+init_helper();
+init_plugin();
+init_debug();
+const LinkHighlightPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "LinkHighlightPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		this.logger = createDebugLogger("plugin", "link-highlight");
+		kernel.registerNodes([LinkHighlightNode]);
+		kernel.registerThemes({ linkHighlight: config?.theme || "editor-link-highlight" });
+		this.urlRegex = config?.urlRegex || /^(?:https?:\/\/|mailto:|tel:)[^\s"<>[\\\]^`{|}]+|^www\.[^\s"<>[\\\]^`{|}]+/i;
+		this.logger.debug("LinkHighlightPlugin initialized");
+	}
+	onInit(editor) {
+		this.register(registerLinkHighlightCommand(editor));
+		this.register(registerLinkHighlight(editor, this.kernel, { enableHotkey: this.config?.enableHotkey }));
+		if (this.config?.enablePasteAutoHighlight !== false) this.register(editor.registerCommand(PASTE_COMMAND, (payload) => {
+			const { clipboardData } = payload;
+			if (clipboardData && clipboardData.types && clipboardData.types.length === 1 && clipboardData.types[0] === "text/plain") {
+				const data = clipboardData.getData("text/plain").trim();
+				if (this.urlRegex.test(data) && isValidUrl(data)) {
+					payload.stopImmediatePropagation();
+					payload.preventDefault();
+					this.logger.debug("Auto-highlighting pasted URL:", data);
+					editor.update(() => {
+						const selection = $getSelection();
+						if ($isRangeSelection(selection)) {
+							const linkHighlightNode = $createLinkHighlightNode();
+							const textNode = $createTextNode(data);
+							linkHighlightNode.append(textNode);
+							selection.insertNodes([linkHighlightNode]);
+						}
+					});
+					return true;
+				}
+			}
+			return false;
+		}, COMMAND_PRIORITY_NORMAL));
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		if (!markdownService) return;
+		markdownService.registerMarkdownWriter(LinkHighlightNode.getType(), (ctx, node) => {
+			ctx.appendLine(node.getTextContent());
+			return true;
+		});
+		markdownService.registerMarkdownShortCut({
+			regExp: /<((?:https?:\/\/|mailto:|tel:|www\.)[^\s"<>[\\\]^`{|}]+)>\s?$/,
+			replace: (textNode, match) => {
+				const [, url] = match;
+				if (!url || !isValidUrl(url)) return;
+				this.logger.debug("Converting markdown auto-link to LinkHighlightNode:", url);
+				const linkHighlightNode = $createLinkHighlightNode();
+				const textNodeContent = $createTextNode(url);
+				linkHighlightNode.append(textNodeContent);
+				textNode.replace(linkHighlightNode);
+			},
+			trigger: ">",
+			type: "text-match"
+		});
+		markdownService.registerMarkdownReader("html", (node) => {
+			const match = (node.value || "").match(/^<((?:https?:\/\/|mailto:|tel:|www\.)[^\s"<>[\\\]^`{|}]+)>$/);
+			if (match) {
+				const url = match[1].replaceAll(/[\u200B-\u200D\u2060\uFEFF]/g, "");
+				this.logger.debug("Converting HTML auto-link to LinkHighlightNode:", url);
+				return INodeHelper.createElementNode("linkHighlight", {
+					children: [INodeHelper.createTextNode(url, {})],
+					direction: "ltr",
+					format: "",
+					indent: 0,
+					type: "linkHighlight",
+					version: 1
+				});
+			}
+			return false;
+		}, 1);
+		markdownService.registerMarkdownReader("link", (node, children) => {
+			const url = node.url || "";
+			if (!children || children.length === 0) return false;
+			if (children.filter((child) => child.type === "text").map((child) => child.text || "").join("") === url) {
+				this.logger.debug("Converting markdown auto-link to LinkHighlightNode:", url);
+				return INodeHelper.createElementNode("linkHighlight", {
+					children: [INodeHelper.createTextNode(url, {})],
+					direction: "ltr",
+					format: "",
+					indent: 0,
+					type: "linkHighlight",
+					version: 1
+				});
+			}
+			return false;
+		}, 1);
+		this.logger.debug("LinkHighlightPlugin initialized with markdown support");
+	}
+};
+//#endregion
+export { LinkHighlightPlugin };

package/es/plugins/link-highlight/plugin/registry.js

@@ -0,0 +1,33 @@
+import { HotkeyEnum, init_hotkey } from "../../../types/hotkey.js";
+import { $createCursorNode } from "../../common/node/cursor.js";
+import { LinkHighlightNode } from "../node/link-highlight.js";
+import { INSERT_LINK_HIGHLIGHT_COMMAND } from "../command/index.js";
+import { $getNodeByKey } from "lexical";
+import { mergeRegister } from "@lexical/utils";
+//#region src/plugins/link-highlight/plugin/registry.ts
+init_hotkey();
+function registerLinkHighlight(editor, kernel, options) {
+	const { enableHotkey = true } = options || {};
+	return mergeRegister(editor.registerUpdateListener(({ mutatedNodes }) => {
+		const keys = (mutatedNodes?.get(LinkHighlightNode))?.keys() || [];
+		const needAddBefore = /* @__PURE__ */ new Set();
+		editor.getEditorState().read(() => {
+			for (const key of keys) {
+				const node = $getNodeByKey(key);
+				if (!node) return;
+				if (node.getParent()?.getFirstChild() === node) needAddBefore.add(node);
+			}
+		});
+		if (needAddBefore.size > 0) editor.update(() => {
+			needAddBefore.forEach((node) => {
+				if (!node.getPreviousSibling()) node.insertBefore($createCursorNode());
+			});
+		});
+	}), kernel.registerHotkey(HotkeyEnum.Link, () => editor.dispatchCommand(INSERT_LINK_HIGHLIGHT_COMMAND, void 0), {
+		enabled: enableHotkey,
+		preventDefault: true,
+		stopPropagation: true
+	}));
+}
+//#endregion
+export { registerLinkHighlight };

package/es/plugins/link-highlight/react/ReactLinkHighlightPlugin.d.ts

@@ -0,0 +1,7 @@
+import { ReactLinkHighlightPluginProps } from "./type.js";
+import { FC } from "react";
+
+//#region src/plugins/link-highlight/react/ReactLinkHighlightPlugin.d.ts
+declare const ReactLinkHighlightPlugin: FC<ReactLinkHighlightPluginProps>;
+//#endregion
+export { ReactLinkHighlightPlugin };

package/es/plugins/link-highlight/react/ReactLinkHighlightPlugin.js

@@ -0,0 +1,29 @@
+import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context.js";
+import { MarkdownPlugin } from "../../markdown/plugin/index.js";
+import { LinkHighlightPlugin } from "../plugin/index.js";
+import { styles } from "./style.js";
+import { useLayoutEffect } from "react";
+import { cx } from "antd-style";
+//#region src/plugins/link-highlight/react/ReactLinkHighlightPlugin.tsx
+const ReactLinkHighlightPlugin = ({ className, enableHotkey = true, enablePasteAutoHighlight = true }) => {
+	const [editor] = useLexicalComposerContext();
+	useLayoutEffect(() => {
+		editor.registerPlugin(MarkdownPlugin);
+		editor.registerPlugin(LinkHighlightPlugin, {
+			enableHotkey,
+			enablePasteAutoHighlight,
+			theme: cx(styles.linkHighlight, className)
+		});
+	}, [
+		className,
+		cx,
+		enableHotkey,
+		enablePasteAutoHighlight,
+		editor,
+		styles.linkHighlight
+	]);
+	return null;
+};
+ReactLinkHighlightPlugin.displayName = "ReactLinkHighlightPlugin";
+//#endregion
+export { ReactLinkHighlightPlugin as default };

package/es/plugins/link-highlight/react/index.d.ts

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

package/es/plugins/link-highlight/react/style.js

@@ -0,0 +1,14 @@
+import { createStaticStyles } from "antd-style";
+//#region src/plugins/link-highlight/react/style.ts
+const styles = createStaticStyles(({ css }) => {
+	return { linkHighlight: css`
+      cursor: unset;
+
+      margin-block: 1em;
+      margin-inline: 0;
+      padding: 2px;
+      border: none;
+    ` };
+});
+//#endregion
+export { styles };

package/es/plugins/link-highlight/react/type.d.ts

@@ -0,0 +1,16 @@
+//#region src/plugins/link-highlight/react/type.d.ts
+interface ReactLinkHighlightPluginProps {
+  className?: string;
+  /**
+   * Enable keyboard shortcut (Ctrl+K / Cmd+K)
+   * @default true
+   */
+  enableHotkey?: boolean;
+  /**
+   * Enable auto-highlight when pasting URLs
+   * @default true
+   */
+  enablePasteAutoHighlight?: boolean;
+}
+//#endregion
+export { ReactLinkHighlightPluginProps };

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

@@ -0,0 +1,3 @@
+import { INSERT_CHECK_LIST_COMMAND } from "../plugin/checkList.js";
+import { INSERT_ORDERED_LIST_COMMAND as INSERT_ORDERED_LIST_COMMAND$1, INSERT_UNORDERED_LIST_COMMAND as INSERT_UNORDERED_LIST_COMMAND$1, REMOVE_LIST_COMMAND, UPDATE_LIST_START_COMMAND } from "@lexical/list";
+export { INSERT_ORDERED_LIST_COMMAND$1 as INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND$1 as INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, UPDATE_LIST_START_COMMAND };

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

@@ -0,0 +1,3 @@
+import "../plugin/checkList.js";
+import { INSERT_ORDERED_LIST_COMMAND as INSERT_ORDERED_LIST_COMMAND$1, INSERT_UNORDERED_LIST_COMMAND as INSERT_UNORDERED_LIST_COMMAND$1, REMOVE_LIST_COMMAND, UPDATE_LIST_START_COMMAND } from "@lexical/list";
+export { INSERT_ORDERED_LIST_COMMAND$1 as INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND$1 as INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, UPDATE_LIST_START_COMMAND };

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

@@ -0,0 +1,5 @@
+import { INSERT_CHECK_LIST_COMMAND } from "./plugin/checkList.js";
+import { INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, UPDATE_LIST_START_COMMAND } from "./command/index.js";
+import { ListPlugin, ListPluginOptions } from "./plugin/index.js";
+import { ReactListPluginProps } from "./react/type.js";
+import { ReactListPlugin } from "./react/ReactListPlugin.js";

package/es/plugins/list/plugin/checkList.d.ts

@@ -0,0 +1,6 @@
+import { LexicalCommand, LexicalEditor } from "lexical";
+
+//#region src/plugins/list/plugin/checkList.d.ts
+declare const INSERT_CHECK_LIST_COMMAND: LexicalCommand<void>;
+//#endregion
+export { INSERT_CHECK_LIST_COMMAND };

package/es/plugins/list/plugin/checkList.js

@@ -0,0 +1,140 @@
+import { $getNearestNodeFromDOMNode, $getSelection, $isElementNode, $isRangeSelection, COMMAND_PRIORITY_LOW, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_UP_COMMAND, createCommand, getNearestEditorFromDOMNode } from "lexical";
+import { $findMatchingParent, calculateZoomLevel, isHTMLElement as isHTMLElement$1, mergeRegister } from "@lexical/utils";
+import { $insertList, $isListItemNode, $isListNode } from "@lexical/list";
+//#region src/plugins/list/plugin/checkList.ts
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const INSERT_CHECK_LIST_COMMAND = createCommand("INSERT_CHECK_LIST_COMMAND");
+function isHeadlessEditor(editor) {
+	return editor._headless === true;
+}
+function handleCheckItemEvent(event, callback) {
+	const target = event.target;
+	if (!isHTMLElement$1(target)) return;
+	const firstChild = target.firstChild;
+	if (isHTMLElement$1(firstChild) && (firstChild.tagName === "UL" || firstChild.tagName === "OL")) return;
+	const parentNode = target.parentNode;
+	if (!parentNode || parentNode.__lexicalListType !== "check") return;
+	const rect = target.getBoundingClientRect();
+	const zoom = calculateZoomLevel(target);
+	const clientX = event.clientX / zoom;
+	const beforeStyles = window.getComputedStyle ? window.getComputedStyle(target, "::before") : { width: "0px" };
+	const beforeWidthInPixels = parseFloat(beforeStyles.width);
+	const beforeMargin = parseFloat(beforeStyles.marginLeft);
+	const clickAreaPadding = event.pointerType === "touch" ? 32 : 0;
+	if (target.dir === "rtl" ? clientX < rect.right + clickAreaPadding && clientX > rect.right - beforeWidthInPixels - clickAreaPadding : clientX > rect.left + beforeMargin - clickAreaPadding && clientX < rect.left + beforeMargin + beforeWidthInPixels + clickAreaPadding) callback();
+}
+function handleClick(event) {
+	handleCheckItemEvent(event, () => {
+		if (isHTMLElement$1(event.target)) {
+			const domNode = event.target;
+			const editor = getNearestEditorFromDOMNode(domNode);
+			if (editor && editor.isEditable()) editor.update(() => {
+				const node = $getNearestNodeFromDOMNode(domNode);
+				if ($isListItemNode(node)) {
+					domNode.focus();
+					node.toggleChecked();
+				}
+			});
+		}
+	});
+}
+function handlePointerDown(event) {
+	handleCheckItemEvent(event, () => {
+		event.preventDefault();
+	});
+}
+function getActiveCheckListItem() {
+	const activeElement = document.activeElement;
+	return isHTMLElement$1(activeElement) && activeElement.tagName === "LI" && activeElement.parentNode && activeElement.parentNode.__lexicalListType === "check" ? activeElement : null;
+}
+function findCheckListItemSibling(node, backward) {
+	let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
+	let parent = node;
+	while (!sibling && $isListItemNode(parent)) {
+		parent = parent.getParentOrThrow().getParent();
+		if (parent) sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();
+	}
+	while ($isListItemNode(sibling)) {
+		const firstChild = backward ? sibling.getLastChild() : sibling.getFirstChild();
+		if (!$isListNode(firstChild)) return sibling;
+		sibling = backward ? firstChild.getLastChild() : firstChild.getFirstChild();
+	}
+	return null;
+}
+function handleArrowUpOrDown(event, editor, backward) {
+	const activeItem = getActiveCheckListItem();
+	if (activeItem) editor.update(() => {
+		const listItem = $getNearestNodeFromDOMNode(activeItem);
+		if (!$isListItemNode(listItem)) return;
+		const nextListItem = findCheckListItemSibling(listItem, backward);
+		if (nextListItem) {
+			nextListItem.selectStart();
+			const dom = editor.getElementByKey(nextListItem.__key);
+			if (dom) {
+				event.preventDefault();
+				setTimeout(() => {
+					dom.focus();
+				}, 0);
+			}
+		}
+	});
+	return false;
+}
+function registerCheckList(editor) {
+	const registrations = [
+		editor.registerCommand(INSERT_CHECK_LIST_COMMAND, () => {
+			$insertList("check");
+			return true;
+		}, COMMAND_PRIORITY_LOW),
+		editor.registerCommand(KEY_ARROW_DOWN_COMMAND, (event) => {
+			return handleArrowUpOrDown(event, editor, false);
+		}, COMMAND_PRIORITY_LOW),
+		editor.registerCommand(KEY_ARROW_UP_COMMAND, (event) => {
+			return handleArrowUpOrDown(event, editor, true);
+		}, COMMAND_PRIORITY_LOW),
+		editor.registerCommand(KEY_ARROW_LEFT_COMMAND, (event) => {
+			return editor.getEditorState().read(() => {
+				const selection = $getSelection();
+				if ($isRangeSelection(selection) && selection.isCollapsed()) {
+					const { anchor } = selection;
+					const isElement = anchor.type === "element";
+					if (isElement || anchor.offset === 0) {
+						const anchorNode = anchor.getNode();
+						const elementNode = $findMatchingParent(anchorNode, (node) => $isElementNode(node) && !node.isInline());
+						if ($isListItemNode(elementNode)) {
+							const parent = elementNode.getParent();
+							if ($isListNode(parent) && parent.getListType() === "check" && (isElement || elementNode.getFirstDescendant() === anchorNode)) {
+								const domNode = editor.getElementByKey(elementNode.__key);
+								if (domNode && document.activeElement !== domNode) {
+									domNode.focus();
+									event.preventDefault();
+									return true;
+								}
+							}
+						}
+					}
+				}
+				return false;
+			});
+		}, COMMAND_PRIORITY_LOW)
+	];
+	if (!isHeadlessEditor(editor)) registrations.push(editor.registerRootListener((rootElement, prevElement) => {
+		if (rootElement !== null) {
+			rootElement.addEventListener("click", handleClick);
+			rootElement.addEventListener("pointerdown", handlePointerDown);
+		}
+		if (prevElement !== null) {
+			prevElement.removeEventListener("click", handleClick);
+			prevElement.removeEventListener("pointerdown", handlePointerDown);
+		}
+	}));
+	return mergeRegister(...registrations);
+}
+//#endregion
+export { INSERT_CHECK_LIST_COMMAND, registerCheckList };

package/es/plugins/list/plugin/index.d.ts

@@ -0,0 +1,9 @@
+import { IEditorPluginConstructor } from "../../../types/kernel.js";
+//#region src/plugins/list/plugin/index.d.ts
+interface ListPluginOptions {
+  enableHotkey?: boolean;
+  theme?: string;
+}
+declare const ListPlugin: IEditorPluginConstructor<ListPluginOptions>;
+//#endregion
+export { ListPlugin, ListPluginOptions };

package/es/plugins/list/plugin/index.js

@@ -0,0 +1,195 @@
+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 { cx } from "../../../utils/cx.js";
+import { listReplace } from "../utils/index.js";
+import { registerCheckList } from "./checkList.js";
+import { registerListCommands } from "./registry.js";
+import { $isRootNode } from "lexical";
+import { $getNearestNodeOfType } from "@lexical/utils";
+import { $isListItemNode, $isListNode, ListItemNode, ListNode, registerList, registerListStrictIndentTransform } from "@lexical/list";
+//#region src/plugins/list/plugin/index.ts
+init_helper();
+init_plugin();
+const ORDERED_LIST_REGEX = /^(\s*)(\d+)\.\s/;
+const UNORDERED_LIST_REGEX = /^(\s*)[*+-]\s/;
+const CHECK_LIST_REGEX = /^(\s*)(?:-\s)?\s?(\[(\s|x)?])\s/i;
+const ListPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "ListPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		kernel.registerNodes([ListNode, ListItemNode]);
+		kernel.registerThemes({ list: {
+			checklist: "editor_listItemCheck",
+			listitem: "editor_listItem",
+			listitemChecked: "editor_listItemChecked",
+			listitemUnchecked: "editor_listItemUnchecked",
+			nested: { listitem: "editor_listItemNested" },
+			ol: cx("editor_listOrdered", config?.theme),
+			olDepth: [
+				"editor_listOrdered dp1",
+				"editor_listOrdered dp2",
+				"editor_listOrdered dp3",
+				"editor_listOrdered dp4",
+				"editor_listOrdered dp5"
+			],
+			ul: cx("editor_listUnordered", config?.theme)
+		} });
+	}
+	onInit(editor) {
+		this.register(registerList(editor));
+		this.register(registerCheckList(editor));
+		this.register(registerListStrictIndentTransform(editor));
+		this.register(registerListCommands(editor, this.kernel, { enableHotkey: this.config?.enableHotkey }));
+		this.registerMarkdown();
+		this.registerLiteXml();
+	}
+	registerLiteXml() {
+		const litexmlService = this.kernel.requireService(ILitexmlService);
+		if (!litexmlService) return;
+		litexmlService.registerXMLWriter(ListNode.getType(), (node, ctx) => {
+			if ($isListNode(node)) {
+				const tagName = node.getListType() === "number" ? "ol" : "ul";
+				const attributes = {};
+				if (node.getListType() === "number" && node.getStart() !== 1) attributes.start = node.getStart().toString();
+				return ctx.createXmlNode(tagName, attributes);
+			}
+			return false;
+		});
+		litexmlService.registerXMLWriter(ListItemNode.getType(), (node, ctx) => {
+			if ($isListItemNode(node)) return ctx.createXmlNode("li");
+			return false;
+		});
+		litexmlService.registerXMLReader("ol", (xmlNode, children) => {
+			return INodeHelper.createElementNode("list", {
+				children,
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				listType: "number",
+				start: xmlNode.getAttribute("start") ? parseInt(xmlNode.getAttribute("start"), 10) : 1,
+				tag: "ol",
+				version: 1
+			});
+		});
+		litexmlService.registerXMLReader("ul", (xmlNode, children) => {
+			return INodeHelper.createElementNode("list", {
+				children,
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				listType: "bullet",
+				start: 1,
+				tag: "ul",
+				version: 1
+			});
+		});
+		litexmlService.registerXMLReader("li", (xmlNode, children) => {
+			return INodeHelper.createElementNode("listitem", {
+				children,
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				type: "listitem",
+				version: 1
+			});
+		});
+	}
+	registerMarkdown() {
+		const markdownService = this.kernel.requireService(IMarkdownShortCutService);
+		if (!markdownService) return;
+		markdownService.registerMarkdownShortCut({
+			regExp: UNORDERED_LIST_REGEX,
+			replace: listReplace("bullet"),
+			type: "element"
+		});
+		markdownService.registerMarkdownShortCut({
+			regExp: ORDERED_LIST_REGEX,
+			replace: listReplace("number"),
+			type: "element"
+		});
+		markdownService.registerMarkdownShortCut({
+			regExp: CHECK_LIST_REGEX,
+			replace: listReplace("check"),
+			type: "element"
+		});
+		markdownService.registerMarkdownWriter(ListNode.getType(), (ctx, node) => {
+			if ($isListNode(node)) ctx.wrap("", "\n");
+		});
+		const getLevel = (node) => {
+			if (!node) return 0;
+			if ($isRootNode(node.getParent())) return 0;
+			const parent = node.getParent();
+			if (!parent) return 0;
+			return getLevel($getNearestNodeOfType(parent, ListNode)) + 1;
+		};
+		markdownService.registerMarkdownWriter(ListItemNode.getType(), (ctx, node) => {
+			const parent = node.getParent();
+			if ($isListItemNode(node) && $isListNode(parent)) {
+				if ($isListNode(node.getFirstChild())) return;
+				const level = getLevel(parent);
+				const prefix = "    ".repeat(level);
+				switch (parent.getListType()) {
+					case "bullet":
+						ctx.wrap(prefix + "- ", "\n");
+						break;
+					case "number":
+						ctx.wrap(`${prefix}${node.getValue()}. `, "\n");
+						break;
+					case "check":
+						ctx.wrap(`${prefix}- [${node.getChecked() ? "x" : " "}] `, "\n");
+						break;
+					default: break;
+				}
+			}
+		});
+		markdownService.registerMarkdownReader("list", (node, children) => {
+			const isCheck = node.children?.[0]?.type === "listItem" && typeof node.children?.[0]?.checked === "boolean";
+			let start = node.start || 1;
+			return INodeHelper.createElementNode("list", {
+				children: children.map((v) => {
+					if (v.type === "listitem") v.value = start++;
+					return v;
+				}),
+				direction: "ltr",
+				format: "",
+				indent: 0,
+				listType: isCheck ? "check" : node.ordered ? "number" : "bullet",
+				start: node.start || 1,
+				tag: node.ordered ? "ol" : "ul",
+				version: 1
+			});
+		});
+		markdownService.registerMarkdownReader("listItem", (node, children, index) => {
+			return children.map((v) => {
+				if (v.type === "paragraph") return INodeHelper.createElementNode("listitem", {
+					checked: typeof node.checked === "boolean" ? node.checked : void 0,
+					children: v.children,
+					direction: "ltr",
+					format: "",
+					indent: 0,
+					type: "listitem",
+					value: index + 1,
+					version: 1
+				});
+				else if (v.type === "list") return INodeHelper.createElementNode("listitem", {
+					children: [v],
+					direction: "ltr",
+					format: "",
+					indent: 0,
+					type: "listitem",
+					value: index + 1,
+					version: 1
+				});
+				return v;
+			});
+		});
+	}
+};
+//#endregion
+export { ListPlugin };

package/es/plugins/list/plugin/registry.js

@@ -0,0 +1,68 @@
+import { HotkeyEnum, init_hotkey } from "../../../types/hotkey.js";
+import { $indentOverTab } from "../utils/index.js";
+import { $createParagraphNode, $getSelection, $isRangeSelection, $isRootNode, $isTextNode, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, INDENT_CONTENT_COMMAND, INSERT_TAB_COMMAND, KEY_BACKSPACE_COMMAND, KEY_TAB_COMMAND, OUTDENT_CONTENT_COMMAND } from "lexical";
+import { mergeRegister } from "@lexical/utils";
+import { $createListNode, $isListItemNode, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND } from "@lexical/list";
+//#region src/plugins/list/plugin/registry.ts
+init_hotkey();
+function registerListCommands(editor, kernel, options) {
+	const { enableHotkey = true } = options || {};
+	return mergeRegister(kernel.registerHotkey(HotkeyEnum.BulletList, () => editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, void 0), {
+		enabled: enableHotkey,
+		preventDefault: true,
+		stopImmediatePropagation: true
+	}), kernel.registerHotkey(HotkeyEnum.NumberList, () => editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, void 0), {
+		enabled: enableHotkey,
+		preventDefault: true,
+		stopImmediatePropagation: true
+	}), editor.registerCommand(KEY_TAB_COMMAND, (event) => {
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection)) return false;
+		event.preventDefault();
+		const command = $indentOverTab(selection) ? event.shiftKey ? OUTDENT_CONTENT_COMMAND : INDENT_CONTENT_COMMAND : INSERT_TAB_COMMAND;
+		return editor.dispatchCommand(command, void 0);
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(KEY_BACKSPACE_COMMAND, (event) => {
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection) || !selection.isCollapsed()) return false;
+		const anchor = selection.anchor;
+		if (anchor.offset !== 0) return false;
+		const anchorNode = anchor.getNode();
+		let listItemNode;
+		if ($isListItemNode(anchorNode)) listItemNode = anchorNode;
+		else if ($isTextNode(anchorNode)) {
+			if (anchorNode.getPreviousSibling()) return false;
+			const parent = anchorNode.getParentOrThrow();
+			if (!$isListItemNode(parent)) return false;
+			listItemNode = parent;
+		}
+		if (!listItemNode || !$isRootNode(listItemNode.getParent()?.getParent())) return false;
+		const listNode = listItemNode.getParentOrThrow();
+		queueMicrotask(() => {
+			editor.update(() => {
+				if (!listItemNode) return;
+				let newlistNode;
+				if (listItemNode.getPreviousSibling() === null) {
+					listItemNode.replace($createParagraphNode(), true).select(0, 0);
+					return;
+				}
+				let next = listItemNode.getNextSibling();
+				if (next) newlistNode = $createListNode(listNode.getListType(), listItemNode.getValue());
+				while (next && newlistNode) {
+					next.remove();
+					newlistNode.append(next);
+					next = next.getNextSibling();
+				}
+				const p = listItemNode.replace($createParagraphNode(), true);
+				p.remove();
+				listNode.insertAfter(p);
+				if (newlistNode) p.insertAfter(newlistNode);
+				p.select(0, 0);
+			});
+		});
+		event.stopImmediatePropagation();
+		event.preventDefault();
+		return true;
+	}, COMMAND_PRIORITY_LOW));
+}
+//#endregion
+export { registerListCommands };

package/es/plugins/list/react/ReactListPlugin.d.ts

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