@lobehub/editor 4.24.1 → 4.25.1

package/es/plugins/toc/react/getNearestScrollContainer.d.ts

@@ -0,0 +1,6 @@
+import { IEditor } from "../../../types/kernel.js";
+import "../../../types/index.js";
+//#region src/plugins/toc/react/getNearestScrollContainer.d.ts
+type GetTocScrollContainer = (editor: IEditor) => HTMLElement | Window | null;
+//#endregion
+export { GetTocScrollContainer };

package/es/plugins/toc/react/getNearestScrollContainer.js

@@ -0,0 +1,18 @@
+//#region src/plugins/toc/react/getNearestScrollContainer.ts
+function getNearestScrollContainer(element) {
+	if (!element || typeof window === "undefined") return window;
+	let current = element.parentElement;
+	while (current) {
+		if (current === document.body || current === document.documentElement) return window;
+		const style = window.getComputedStyle(current);
+		const overflow = `${style.overflow} ${style.overflowY} ${style.overflowX}`;
+		if (/(auto|scroll|overlay)/.test(overflow) && current.scrollHeight > current.clientHeight) return current;
+		current = current.parentElement;
+	}
+	return window;
+}
+function resolveTocScrollContainer(editor, getScrollContainer) {
+	return getScrollContainer?.(editor) ?? getNearestScrollContainer(editor.getRootElement());
+}
+//#endregion
+export { getNearestScrollContainer, resolveTocScrollContainer };

package/es/plugins/toc/react/hooks/useActiveHeading.js

@@ -0,0 +1,59 @@
+import { resolveTocScrollContainer } from "../getNearestScrollContainer.js";
+import { useEffect } from "react";
+//#region src/plugins/toc/react/hooks/useActiveHeading.ts
+function useActiveHeading({ editor, getScrollContainer, offsetTop, service }) {
+	useEffect(() => {
+		const lexicalEditor = editor.getLexicalEditor();
+		if (!lexicalEditor || !service) {
+			service?.setActiveKey(null);
+			return;
+		}
+		const scrollContainer = resolveTocScrollContainer(editor, getScrollContainer);
+		let frameId = null;
+		const measure = () => {
+			const flatItems = service.getFlatItems();
+			if (flatItems.length === 0) {
+				service.setActiveKey(null);
+				return;
+			}
+			let nextActiveKey = flatItems[0]?.key ?? null;
+			const containerTop = scrollContainer instanceof Window ? 0 : scrollContainer.getBoundingClientRect().top;
+			for (const item of flatItems) {
+				const element = lexicalEditor.getElementByKey(item.key);
+				if (!element) continue;
+				if (element.getBoundingClientRect().top - containerTop <= offsetTop + 1) nextActiveKey = item.key;
+				else break;
+			}
+			service.setActiveKey(nextActiveKey);
+		};
+		const scheduleMeasure = () => {
+			if (frameId !== null) return;
+			frameId = window.requestAnimationFrame(() => {
+				frameId = null;
+				measure();
+			});
+		};
+		measure();
+		const scrollOptions = { passive: true };
+		const documentScrollOptions = {
+			capture: true,
+			passive: true
+		};
+		scrollContainer.addEventListener("scroll", scheduleMeasure, scrollOptions);
+		document.addEventListener("scroll", scheduleMeasure, documentScrollOptions);
+		window.addEventListener("resize", scheduleMeasure);
+		return () => {
+			if (frameId !== null) window.cancelAnimationFrame(frameId);
+			scrollContainer.removeEventListener("scroll", scheduleMeasure, false);
+			document.removeEventListener("scroll", scheduleMeasure, true);
+			window.removeEventListener("resize", scheduleMeasure);
+		};
+	}, [
+		editor,
+		getScrollContainer,
+		offsetTop,
+		service
+	]);
+}
+//#endregion
+export { useActiveHeading };

package/es/plugins/toc/react/hooks/useTocItems.js

@@ -0,0 +1,50 @@
+import { ITocService } from "../../service/i-toc-service.js";
+import { useEffect, useRef, useState } from "react";
+//#region src/plugins/toc/react/hooks/useTocItems.ts
+function useTocItems({ editor, maxDepth, minDepth, onItemsChange }) {
+	const onItemsChangeRef = useRef(onItemsChange);
+	const [service, setService] = useState(() => editor.requireService(ITocService));
+	const [activeKey, setActiveKey] = useState(null);
+	const [items, setItems] = useState([]);
+	onItemsChangeRef.current = onItemsChange;
+	useEffect(() => {
+		let unsubscribeService;
+		const attachService = () => {
+			const tocService = editor.requireService(ITocService);
+			if (!tocService) return;
+			unsubscribeService?.();
+			unsubscribeService = void 0;
+			tocService.setDepthRange({
+				maxDepth,
+				minDepth
+			});
+			tocService.refresh();
+			setService(tocService);
+			const sync = () => {
+				const nextItems = tocService.getItems();
+				setItems(nextItems);
+				setActiveKey(tocService.getActiveKey());
+				onItemsChangeRef.current?.(nextItems);
+			};
+			sync();
+			unsubscribeService = tocService.subscribe(sync);
+		};
+		attachService();
+		editor.on("initialized", attachService);
+		return () => {
+			editor.off("initialized", attachService);
+			unsubscribeService?.();
+		};
+	}, [
+		editor,
+		maxDepth,
+		minDepth
+	]);
+	return {
+		activeKey,
+		items,
+		service
+	};
+}
+//#endregion
+export { useTocItems };

package/es/plugins/toc/react/index.d.ts

@@ -0,0 +1,5 @@
+import { TocHeadingTag, TocItem } from "../types.js";
+import { ReactTocPluginProps, UseTocOptions, UseTocResult } from "./type.js";
+import ReactTocPlugin from "./ReactTocPlugin.js";
+import { useToc } from "./useToc.js";
+export { ReactTocPlugin, type ReactTocPluginProps, type TocHeadingTag, type TocItem, type UseTocOptions, type UseTocResult, useToc };

package/es/plugins/toc/react/type.d.ts

@@ -0,0 +1,30 @@
+import { IEditor } from "../../../types/kernel.js";
+import "../../../types/index.js";
+import { TocHeadingTag, TocItem, TocScrollBehavior } from "../types.js";
+import { ITocService } from "../service/i-toc-service.js";
+import "../service/index.js";
+import { GetTocScrollContainer } from "./getNearestScrollContainer.js";
+//#region src/plugins/toc/react/type.d.ts
+interface ReactTocPluginProps {
+  editor?: IEditor;
+  maxDepth?: number;
+  minDepth?: number;
+}
+interface UseTocOptions {
+  /** @default 'smooth' */
+  behavior?: TocScrollBehavior;
+  editor: IEditor;
+  getScrollContainer?: GetTocScrollContainer;
+  maxDepth?: number;
+  minDepth?: number;
+  offsetTop?: number;
+  onItemsChange?: (items: TocItem[]) => void;
+}
+interface UseTocResult {
+  activeKey: null | string;
+  items: TocItem[];
+  jumpTo: (key: string) => void;
+  service: ITocService | null;
+}
+//#endregion
+export { ReactTocPluginProps, type TocHeadingTag, type TocItem, UseTocOptions, UseTocResult };

package/es/plugins/toc/react/useToc.d.ts

@@ -0,0 +1,5 @@
+import { UseTocOptions, UseTocResult } from "./type.js";
+//#region src/plugins/toc/react/useToc.d.ts
+declare function useToc({ behavior, editor, getScrollContainer, maxDepth, minDepth, offsetTop, onItemsChange }: UseTocOptions): UseTocResult;
+//#endregion
+export { useToc };

package/es/plugins/toc/react/useToc.js

@@ -0,0 +1,41 @@
+"use client";
+import { resolveTocScrollContainer } from "./getNearestScrollContainer.js";
+import { useActiveHeading } from "./hooks/useActiveHeading.js";
+import { useTocItems } from "./hooks/useTocItems.js";
+import { useCallback } from "react";
+//#region src/plugins/toc/react/useToc.ts
+function useToc({ behavior = "smooth", editor, getScrollContainer, maxDepth = 6, minDepth = 1, offsetTop = 0, onItemsChange }) {
+	const { activeKey, items, service } = useTocItems({
+		editor,
+		maxDepth,
+		minDepth,
+		onItemsChange
+	});
+	useActiveHeading({
+		editor,
+		getScrollContainer,
+		offsetTop,
+		service
+	});
+	return {
+		activeKey,
+		items,
+		jumpTo: useCallback((key) => {
+			const container = resolveTocScrollContainer(editor, getScrollContainer);
+			service?.jumpTo(key, {
+				behavior,
+				container,
+				offsetTop
+			});
+		}, [
+			behavior,
+			editor,
+			getScrollContainer,
+			offsetTop,
+			service
+		]),
+		service
+	};
+}
+//#endregion
+export { useToc };

package/es/plugins/toc/service/i-toc-service.d.ts

@@ -0,0 +1,39 @@
+import { IServiceID } from "../../../types/kernel.js";
+import "../../../types/index.js";
+import { TocHeadingTag, TocItem, TocJumpOptions, TocPluginOptions } from "../types.js";
+import EventEmitter from "eventemitter3";
+import { LexicalEditor } from "lexical";
+//#region src/plugins/toc/service/i-toc-service.d.ts
+interface ITocService {
+  getActiveKey(): null | string;
+  getFlatItems(): TocItem[];
+  getItems(): TocItem[];
+  jumpTo(key: string, options?: TocJumpOptions): boolean;
+  refresh(): TocItem[];
+  setActiveKey(key: null | string): void;
+  setDepthRange(options: TocPluginOptions): void;
+  subscribe(listener: () => void): () => void;
+}
+declare const ITocService: IServiceID<ITocService>;
+type TocServiceEvents = {
+  change: () => void;
+};
+declare class TocService extends EventEmitter<TocServiceEvents> implements ITocService {
+  private activeKey;
+  private editor;
+  private items;
+  private maxDepth;
+  private minDepth;
+  bindEditor(editor: LexicalEditor): void;
+  getActiveKey(): null | string;
+  getFlatItems(): TocItem[];
+  getItems(): TocItem[];
+  jumpTo(key: string, options?: TocJumpOptions): boolean;
+  refresh(): TocItem[];
+  setActiveKey(key: null | string): void;
+  setDepthRange(options: TocPluginOptions): void;
+  subscribe(listener: () => void): () => void;
+  private updateItems;
+}
+//#endregion
+export { ITocService, type TocJumpOptions, type TocPluginOptions, TocService };

package/es/plugins/toc/service/i-toc-service.js

@@ -0,0 +1,125 @@
+import { genServiceId, init_utils } from "../../../editor-kernel/utils.js";
+import { buildTocTree, flattenTocTree } from "../utils/index.js";
+import EventEmitter from "eventemitter3";
+import { $getRoot, $isElementNode } from "lexical";
+import { $isHeadingNode } from "@lexical/rich-text";
+//#region src/plugins/toc/service/i-toc-service.ts
+init_utils();
+const ITocService = genServiceId("TocService");
+function walkHeadings(node, headings, minDepth, maxDepth) {
+	if ($isHeadingNode(node)) {
+		const tag = node.getTag();
+		const depth = Number(tag.slice(1));
+		const title = node.getTextContent().trim();
+		if (title && depth >= minDepth && depth <= maxDepth) headings.push({
+			depth,
+			key: node.getKey(),
+			tag,
+			title
+		});
+	}
+	if ($isElementNode(node)) for (const child of node.getChildren()) walkHeadings(child, headings, minDepth, maxDepth);
+}
+function isSameTocItems(a, b) {
+	const flatA = flattenTocTree(a);
+	const flatB = flattenTocTree(b);
+	if (flatA.length !== flatB.length) return false;
+	return flatA.every((item, index) => {
+		const next = flatB[index];
+		return item.key === next.key && item.depth === next.depth && item.tag === next.tag && item.title === next.title;
+	});
+}
+var TocService = class extends EventEmitter {
+	constructor(..._args) {
+		super(..._args);
+		this.activeKey = null;
+		this.editor = null;
+		this.items = [];
+		this.maxDepth = 6;
+		this.minDepth = 1;
+	}
+	bindEditor(editor) {
+		this.editor = editor;
+	}
+	getActiveKey() {
+		return this.activeKey;
+	}
+	getFlatItems() {
+		return flattenTocTree(this.items);
+	}
+	getItems() {
+		return this.items;
+	}
+	jumpTo(key, options) {
+		const element = this.editor?.getElementByKey(key);
+		if (!element) return false;
+		const behavior = options?.behavior ?? "smooth";
+		const offsetTop = options?.offsetTop ?? 0;
+		const scrollContainer = options?.container;
+		if (typeof window === "undefined") {
+			element.scrollIntoView({
+				behavior,
+				block: options?.block ?? "start"
+			});
+			this.setActiveKey(key);
+			return true;
+		}
+		if (!scrollContainer || scrollContainer instanceof Window) {
+			const top = element.getBoundingClientRect().top + window.scrollY - offsetTop;
+			window.scrollTo({
+				behavior,
+				top
+			});
+		} else {
+			const containerTop = scrollContainer.getBoundingClientRect().top;
+			const top = scrollContainer.scrollTop + element.getBoundingClientRect().top - containerTop - offsetTop;
+			scrollContainer.scrollTo({
+				behavior,
+				top
+			});
+		}
+		this.setActiveKey(key);
+		return true;
+	}
+	refresh() {
+		if (!this.editor) {
+			this.updateItems([]);
+			return [];
+		}
+		const items = this.editor.getEditorState().read(() => {
+			const headings = [];
+			walkHeadings($getRoot(), headings, this.minDepth, this.maxDepth);
+			return buildTocTree(headings);
+		});
+		this.updateItems(items);
+		return items;
+	}
+	setActiveKey(key) {
+		if (this.activeKey === key) return;
+		this.activeKey = key;
+		this.emit("change");
+	}
+	setDepthRange(options) {
+		const minDepth = options.minDepth ?? 1;
+		const maxDepth = options.maxDepth ?? 6;
+		if (this.minDepth === minDepth && this.maxDepth === maxDepth) return;
+		this.minDepth = minDepth;
+		this.maxDepth = maxDepth;
+		this.refresh();
+	}
+	subscribe(listener) {
+		this.on("change", listener);
+		return () => {
+			this.off("change", listener);
+		};
+	}
+	updateItems(items) {
+		if (isSameTocItems(this.items, items)) return;
+		this.items = items;
+		const flatItems = this.getFlatItems();
+		if (this.activeKey && !flatItems.some((item) => item.key === this.activeKey)) this.activeKey = flatItems[0]?.key ?? null;
+		this.emit("change");
+	}
+};
+//#endregion
+export { ITocService, TocService };

package/es/plugins/toc/service/index.d.ts

@@ -0,0 +1,3 @@
+import { TocHeadingTag, TocItem, TocJumpOptions, TocPluginOptions } from "../types.js";
+import { ITocService, TocService } from "./i-toc-service.js";
+export { ITocService, type TocJumpOptions, type TocPluginOptions, TocService };

package/es/plugins/toc/types.d.ts

@@ -0,0 +1,23 @@
+//#region src/plugins/toc/types.d.ts
+type TocHeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+interface TocItem {
+  children: TocItem[];
+  depth: number;
+  key: string;
+  tag: TocHeadingTag;
+  title: string;
+}
+interface TocPluginOptions {
+  maxDepth?: number;
+  minDepth?: number;
+}
+type TocScrollBehavior = 'auto' | 'instant' | 'smooth';
+type TocScrollLogicalPosition = 'center' | 'end' | 'nearest' | 'start';
+interface TocJumpOptions {
+  behavior?: TocScrollBehavior;
+  block?: TocScrollLogicalPosition;
+  container?: HTMLElement | Window | null;
+  offsetTop?: number;
+}
+//#endregion
+export { TocHeadingTag, TocItem, TocJumpOptions, TocPluginOptions, TocScrollBehavior, TocScrollLogicalPosition };

package/es/plugins/toc/utils/index.d.ts

@@ -0,0 +1,6 @@
+import { TocItem } from "../types.js";
+//#region src/plugins/toc/utils/index.d.ts
+declare function buildTocTree(items: Omit<TocItem, 'children'>[]): TocItem[];
+declare function flattenTocTree(items: TocItem[]): TocItem[];
+//#endregion
+export { buildTocTree, flattenTocTree };

package/es/plugins/toc/utils/index.js

@@ -0,0 +1,30 @@
+//#region src/plugins/toc/utils/index.ts
+function buildTocTree(items) {
+	const roots = [];
+	const stack = [];
+	for (const item of items) {
+		const current = {
+			...item,
+			children: []
+		};
+		while (stack.length > 0 && stack.at(-1).depth >= current.depth) stack.pop();
+		const parent = stack.at(-1);
+		if (parent) parent.children.push(current);
+		else roots.push(current);
+		stack.push(current);
+	}
+	return roots;
+}
+function flattenTocTree(items) {
+	const result = [];
+	const walk = (tocItems) => {
+		for (const item of tocItems) {
+			result.push(item);
+			walk(item.children);
+		}
+	};
+	walk(items);
+	return result;
+}
+//#endregion
+export { buildTocTree, flattenTocTree };

package/es/plugins/toolbar/react/index.js

@@ -26,6 +26,7 @@ const ReactToolbarPlugin = ({ className, children, getPopupContainer, usePortal
 	const [kernelEditor] = useLexicalComposerContext();
 	const { isDarkMode } = useThemeMode();
 	const isMouseDownRef = useRef(false);
+	const linkToolbarSuppressionTokenRef = useRef(null);
 	const logger = createDebugLogger("plugin", "toolbar");
 	const resolvePortalContainer = useCallback(() => {
 		if (!usePortal) return null;
@@ -36,6 +37,20 @@ const ReactToolbarPlugin = ({ className, children, getPopupContainer, usePortal
 		const nextContainer = resolvePortalContainer();
 		setPortalContainer((current) => current === nextContainer ? current : nextContainer);
 	}, [resolvePortalContainer]);
+	const getLinkService = useCallback(() => {
+		return kernelEditor.requireService(ILinkService);
+	}, [kernelEditor]);
+	const suppressLinkToolbar = useCallback(() => {
+		const linkService = getLinkService();
+		if (!linkService || linkToolbarSuppressionTokenRef.current) return;
+		linkToolbarSuppressionTokenRef.current = linkService.suppressLinkToolbar("text-format-toolbar");
+	}, [getLinkService]);
+	const restoreLinkToolbar = useCallback(() => {
+		const token = linkToolbarSuppressionTokenRef.current;
+		if (!token) return;
+		linkToolbarSuppressionTokenRef.current = null;
+		getLinkService()?.restoreLinkToolbar(token);
+	}, [getLinkService]);
 	const $updateTextFormatFloatingToolbar = useCallback((editor) => {
 		if (!anchorElemRef.current) return;
 		const selection = $getSelection();
@@ -47,18 +62,25 @@ const ReactToolbarPlugin = ({ className, children, getPopupContainer, usePortal
 			const rangeRect = getDOMRangeRect(nativeSelection, rootElement);
 			logger.debug("🔍 rangeRect", rangeRect);
 			setFloatingElemPosition(rangeRect, popupCharStylesEditorElem, anchorElemRef.current, false);
+			suppressLinkToolbar();
 		} else {
 			popupCharStylesEditorElem.style.opacity = "0";
 			popupCharStylesEditorElem.style.transform = "translate(-10000px, -10000px)";
+			restoreLinkToolbar();
 		}
-	}, [anchorElemRef]);
+	}, [
+		anchorElemRef,
+		restoreLinkToolbar,
+		suppressLinkToolbar
+	]);
 	const $hideFloatingToolbar = useCallback(() => {
 		if (!anchorElemRef.current) return;
 		const popupCharStylesEditorElem = popupCharStylesEditorRef.current;
 		if (popupCharStylesEditorElem === null) return;
 		popupCharStylesEditorElem.style.opacity = "0";
 		popupCharStylesEditorElem.style.transform = "translate(-10000px, -10000px)";
-	}, [anchorElemRef]);
+		restoreLinkToolbar();
+	}, [anchorElemRef, restoreLinkToolbar]);
 	const handleMouseDownFactory = useCallback((updateToolbar) => (e) => {
 		if (e.button === 0) {
 			isMouseDownRef.current = true;
@@ -71,15 +93,6 @@ const ReactToolbarPlugin = ({ className, children, getPopupContainer, usePortal
 			updateToolbar();
 		}
 	}, []);
-	useLexicalEditor(() => {
-		const service = kernelEditor.requireService(ILinkService);
-		if (service) {
-			service.setLinkToolbar(false);
-			return () => {
-				service.setLinkToolbar(true);
-			};
-		}
-	}, []);
 	useLexicalEditor((editor) => {
 		if (!usePortal) {
 			setPortalContainer(null);
@@ -132,6 +145,7 @@ const ReactToolbarPlugin = ({ className, children, getPopupContainer, usePortal
 			if (!isMouseDownRef.current) $updateTextFormatFloatingToolbar(editor);
 			return false;
 		}, COMMAND_PRIORITY_LOW), () => {
+			restoreLinkToolbar();
 			if (rootElement) {
 				rootElement.removeEventListener("mousedown", handleMouseDown);
 				document.removeEventListener("mouseup", handleMouseUp);
@@ -143,7 +157,7 @@ const ReactToolbarPlugin = ({ className, children, getPopupContainer, usePortal
 				if (animationFrameId !== null) editorWindow.cancelAnimationFrame(animationFrameId);
 			}
 		});
-	});
+	}, [restoreLinkToolbar]);
 	const toolbarNode = /* @__PURE__ */ jsx("div", {
 		className: usePortal ? styles.portalAnchor : styles.anchor,
 		ref: anchorElemRef,

package/es/plugins/toolbar/react/style.js

@@ -1,5 +1,6 @@
 import { createStaticStyles } from "antd-style";
 //#region src/plugins/toolbar/react/style.ts
+const FLOATING_TOOLBAR_Z_INDEX = 1001;
 const styles = createStaticStyles(({ css, cssVar }) => ({
 	anchor: css`
     position: relative;
@@ -15,7 +16,7 @@ const styles = createStaticStyles(({ css, cssVar }) => ({
     will-change: transform;
 
     position: absolute;
-    z-index: 10;
+    z-index: ${FLOATING_TOOLBAR_Z_INDEX};
     inset-block-start: 0;
     inset-inline-start: 0;
     transform: translate(-10000px, -10000px);
@@ -39,7 +40,7 @@ const styles = createStaticStyles(({ css, cssVar }) => ({
     will-change: transform;
 
     position: absolute;
-    z-index: 10;
+    z-index: ${FLOATING_TOOLBAR_Z_INDEX};
     inset-block-start: 0;
     inset-inline-start: 0;
     transform: translate(-10000px, -10000px);

package/es/plugins/virtual-block/plugin/register.js

@@ -1,9 +1,9 @@
 import { createDebugLogger, init_debug } from "../../../utils/debug.js";
 import { $closest, init_utils } from "../../../editor-kernel/utils.js";
 import { SELECT_AFTER_CODEMIRROR_COMMAND, SELECT_BEFORE_CODEMIRROR_COMMAND } from "../../codemirror-block/command/index.js";
-import { $createParagraphNode, $getNodeByKey, $getRoot, $getSelection, $isDecoratorNode, $isNodeSelection, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, COMMAND_PRIORITY_NORMAL, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, ParagraphNode } from "lexical";
+import { $createParagraphNode, $getNodeByKey, $getRoot, $getSelection, $isDecoratorNode, $isElementNode, $isNodeSelection, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, COMMAND_PRIORITY_NORMAL, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, ParagraphNode } from "lexical";
 import { mergeRegister } from "@lexical/utils";
-import "@lexical/code-core";
+import { $isListItemNode, $isListNode } from "@lexical/list";
 //#region src/plugins/virtual-block/plugin/register.ts
 init_utils();
 init_debug();
@@ -21,9 +21,36 @@ function $isEmptyNode(node) {
 	if (node.getChildrenSize() === 0) return true;
 	for (const child of node.getChildren()) if ($isTextNode(child)) {
 		if (child.getTextContent().trim().length > 0) return false;
-	} else if (!$isEmptyNode(child)) return false;
+	} else if ($isElementNode(child)) {
+		if (!$isEmptyNode(child)) return false;
+	} else return false;
 	return true;
 }
+function $getTopLevelListItem(selection) {
+	const focusNode = selection.focus.getNode();
+	const listNode = toRootElement(focusNode);
+	if (!$isListNode(listNode)) return null;
+	let current = focusNode;
+	while (current.getParent() !== listNode) {
+		const parent = current.getParent();
+		if (!parent || $isRootOrShadowRoot(parent)) return null;
+		current = parent;
+	}
+	if (!$isListItemNode(current)) return null;
+	return {
+		listItem: current,
+		listNode
+	};
+}
+function $isListBoundarySelection(selection, isBackward) {
+	if (!selection.isCollapsed()) return false;
+	const focusNode = selection.focus.getNode();
+	if ($isListNode(focusNode)) return isBackward ? selection.focus.offset === 0 : selection.focus.offset === focusNode.getChildrenSize();
+	const listContext = $getTopLevelListItem(selection);
+	if (!listContext) return false;
+	const { listItem } = listContext;
+	return isBackward ? !listItem.getPreviousSibling() : !listItem.getNextSibling();
+}
 function registerRichKeydown(editor, kernel) {
 	let needRemoveOnFocusNode = null;
 	return mergeRegister(editor.registerUpdateListener((payload) => {
@@ -76,14 +103,8 @@ function registerRichKeydown(editor, kernel) {
 		} else if ($isRangeSelection(selection)) {
 			const possibleNode = toRootElement(selection.focus.getNode());
 			if (possibleNode === needRemoveOnFocusNode || $isEmptyNode(possibleNode)) return false;
-			if ($getRoot().getFirstChild() === possibleNode) {
-				event.preventDefault();
-				const p = $createParagraphNode();
-				possibleNode.insertBefore(p);
-				needRemoveOnFocusNode = p;
-				p.selectStart();
-				return true;
-			} else if ($isDecoratorNode(possibleNode.getPreviousSibling())) {
+			if ($isListNode(possibleNode) && !$isListBoundarySelection(selection, true)) return false;
+			if ($getRoot().getFirstChild() === possibleNode || $isDecoratorNode(possibleNode.getPreviousSibling())) {
 				event.preventDefault();
 				const p = $createParagraphNode();
 				possibleNode.insertBefore(p);
@@ -111,14 +132,15 @@ function registerRichKeydown(editor, kernel) {
 			if (!selection.isCollapsed()) return false;
 			const possibleNode = toRootElement(selection.focus.getNode());
 			if (possibleNode === needRemoveOnFocusNode || $isEmptyNode(possibleNode)) return false;
+			if ($isListNode(possibleNode) && !$isListBoundarySelection(selection, false)) return false;
 			if ($getRoot().getLastChild() === possibleNode) {
 				event.preventDefault();
 				const p = $createParagraphNode();
 				possibleNode.insertAfter(p);
 				needRemoveOnFocusNode = p;
 				p.selectStart();
+				return true;
 			}
-			return true;
 		}
 		return false;
 	}, COMMAND_PRIORITY_NORMAL), editor.registerCommand(SELECT_BEFORE_CODEMIRROR_COMMAND, (payload) => {

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

@@ -0,0 +1,6 @@
+import { YjsInitialEditorState, YjsPluginOptions, YjsProviderFactory } from "./plugin/types.js";
+import { YjsPlugin } from "./plugin/index.js";
+import { Doc, ReactYjsPlugin, ReactYjsPluginProps } from "./react/index.js";
+import { IYjsService, YjsAwarenessUser, YjsPluginState, YjsService } from "./service/index.js";
+import { CreateWebSocketYjsProviderOptions, WebSocketYjsProvider, WebSocketYjsProviderStatus, createWebSocketYjsProvider, fetchWebSocketDemoDocument, saveWebSocketDemoDocument, snapshotWebSocketDemoDocument } from "./websocket-provider.js";
+export { CreateWebSocketYjsProviderOptions, type Doc, IYjsService, ReactYjsPlugin, ReactYjsPluginProps, WebSocketYjsProvider, WebSocketYjsProviderStatus, YjsAwarenessUser, type YjsInitialEditorState, YjsPlugin, type YjsPluginOptions, YjsPluginState, type YjsProviderFactory, YjsService, createWebSocketYjsProvider, fetchWebSocketDemoDocument, saveWebSocketDemoDocument, snapshotWebSocketDemoDocument };

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

@@ -0,0 +1,7 @@
+import { IEditorPluginConstructor } from "../../../types/kernel.js";
+import "../../../types/index.js";
+import { YjsInitialEditorState, YjsPluginOptions, YjsProviderFactory } from "./types.js";
+//#region src/plugins/yjs/plugin/index.d.ts
+declare const YjsPlugin: IEditorPluginConstructor<YjsPluginOptions>;
+//#endregion
+export { type YjsInitialEditorState, YjsPlugin, type YjsPluginOptions, type YjsProviderFactory };