@lobehub/editor 4.15.1 → 4.15.2

package/es/plugins/auto-complete/react/type.d.ts

@@ -0,0 +1,25 @@
+import { IEditor } from "../../../types/kernel.js";
+//#region src/plugins/auto-complete/react/type.d.ts
+interface ReactAutoCompletePluginProps {
+  delay?: number;
+  onAutoComplete?: (opt: {
+    abortSignal: AbortSignal;
+    afterText: string;
+    editor: IEditor;
+    input: string;
+    selectionType: string;
+    suggestionId?: string;
+  }) => Promise<string | null>;
+  onSuggestionAccepted?: (info: {
+    acceptedText: string;
+    suggestionId: string;
+    visibleMs: number;
+  }) => void;
+  onSuggestionRejected?: (info: {
+    reason: 'cursor-move' | 'typing' | 'esc' | 'blur' | 'other';
+    suggestionId: string;
+    visibleMs: number;
+  }) => void;
+}
+//#endregion
+export { ReactAutoCompletePluginProps };

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

@@ -0,0 +1,13 @@
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/block/command/index.d.ts
+interface BlockMovePayload {
+  placement: 'after' | 'before';
+  sourceBlockId: string;
+  targetBlockId: string;
+}
+declare const MOVE_BLOCK_COMMAND: _$lexical.LexicalCommand<BlockMovePayload>;
+declare function registerBlockMoveCommand(editor: LexicalEditor): () => void;
+//#endregion
+export { BlockMovePayload, MOVE_BLOCK_COMMAND, registerBlockMoveCommand };

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

@@ -0,0 +1,161 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { $createParagraphNode, $getNodeByKey, $isParagraphNode, $isRootNode, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+import { $createListItemNode, $createListNode, $isListItemNode, $isListNode } from "@lexical/list";
+//#region src/plugins/block/command/index.ts
+init_debug();
+const MOVE_BLOCK_COMMAND = createCommand("MOVE_BLOCK_COMMAND");
+const logger = createDebugLogger("plugin", "block-command");
+const getListParent = (node) => {
+	if (!node) return null;
+	const parent = node.getParent();
+	return $isListNode(parent) ? parent : null;
+};
+const getTopListContextFromItem = (item) => {
+	let currentItem = item;
+	let currentList = getListParent(item);
+	while (currentList && $isListItemNode(currentList.getParent())) {
+		currentItem = currentList.getParent();
+		currentList = getListParent(currentItem);
+	}
+	return {
+		item: currentItem,
+		list: currentList
+	};
+};
+const cloneListTail = (listNode, tailStart, fallbackStartValue) => {
+	if (!tailStart) return null;
+	const newListNode = $createListNode(listNode.getListType(), fallbackStartValue);
+	let current = tailStart;
+	while (current) {
+		const nextSibling = current.getNextSibling();
+		current.remove();
+		newListNode.append(current);
+		current = nextSibling;
+	}
+	return newListNode;
+};
+const alignListItemDepth = (item, target) => {
+	const targetWithIndent = target;
+	const itemWithIndent = item;
+	if (typeof targetWithIndent.getIndent === "function" && typeof itemWithIndent.setIndent === "function") itemWithIndent.setIndent(targetWithIndent.getIndent());
+};
+const cleanupEmptyListForItem = (listItem) => {
+	const parentList = getListParent(listItem);
+	if (parentList && parentList.getChildrenSize() === 0) parentList.remove();
+};
+const moveBlockNode = (payload) => {
+	logger.debug("start", payload);
+	const sourceNode = $getNodeByKey(payload.sourceBlockId);
+	const targetNode = $getNodeByKey(payload.targetBlockId);
+	if (!sourceNode || !targetNode) {
+		logger.debug("abort: node-not-found", {
+			sourceFound: Boolean(sourceNode),
+			targetFound: Boolean(targetNode)
+		});
+		return;
+	}
+	if (sourceNode === targetNode) {
+		logger.debug("abort: source-equals-target");
+		return;
+	}
+	if (!$isListItemNode(targetNode)) {
+		const sourceIsListItem = $isListItemNode(sourceNode);
+		let movingNode = sourceNode;
+		logger.debug("branch: normal-block-target", {
+			placement: payload.placement,
+			targetType: targetNode.getType()
+		});
+		if (sourceIsListItem) {
+			const sourceListItem = sourceNode;
+			const paragraphNode = $createParagraphNode();
+			paragraphNode.append(...sourceListItem.getChildren());
+			sourceListItem.remove();
+			cleanupEmptyListForItem(sourceListItem);
+			movingNode = paragraphNode;
+			logger.debug("convert: listItem-to-paragraph", { sourceType: sourceNode.getType() });
+		}
+		if (payload.placement === "before") targetNode.insertBefore(movingNode);
+		else targetNode.insertAfter(movingNode);
+		logger.debug("done: normal-block-target");
+		return;
+	}
+	const targetListItem = targetNode;
+	const sourceIsListItem = $isListItemNode(sourceNode);
+	const sourceIsParagraph = $isParagraphNode(sourceNode);
+	if (sourceIsListItem || sourceIsParagraph) {
+		logger.debug("branch: list-insert-with-item-or-paragraph", {
+			sourceIsListItem,
+			sourceIsParagraph,
+			targetType: targetListItem.getType()
+		});
+		let movingListItem;
+		if (sourceIsListItem) movingListItem = sourceNode;
+		else {
+			const sourceParagraph = sourceNode;
+			const targetListType = getListParent(targetListItem)?.getListType();
+			const targetChecked = targetListItem.getChecked?.();
+			const newListItem = $createListItemNode(targetListType === "check" ? targetChecked : void 0);
+			newListItem.append(...sourceParagraph.getChildren());
+			sourceParagraph.remove();
+			movingListItem = newListItem;
+		}
+		alignListItemDepth(movingListItem, targetListItem);
+		if (payload.placement === "before") targetListItem.insertBefore(movingListItem);
+		else targetListItem.insertAfter(movingListItem);
+		logger.debug("done: list-insert-with-item-or-paragraph");
+		return;
+	}
+	const topContext = getTopListContextFromItem(targetListItem);
+	const topListNode = topContext.list;
+	const topListItem = topContext.item;
+	if (!topListNode) {
+		logger.debug("branch: list-target-without-top-list", { placement: payload.placement });
+		if (payload.placement === "before") targetListItem.insertBefore(sourceNode);
+		else targetListItem.insertAfter(sourceNode);
+		logger.debug("done: list-target-without-top-list");
+		return;
+	}
+	const tailStart = payload.placement === "before" ? topListItem : topListItem.getNextSibling();
+	if (tailStart === topListItem && topListItem.getPreviousSibling() === null) {
+		logger.debug("branch: split-list-head-insert-before-list");
+		topListNode.insertBefore(sourceNode);
+		logger.debug("done: split-list-head-insert-before-list");
+		return;
+	}
+	if (!tailStart) {
+		logger.debug("branch: split-list-tail-insert-after-list");
+		topListNode.insertAfter(sourceNode);
+		logger.debug("done: split-list-tail-insert-after-list");
+		return;
+	}
+	const listStartValue = $isListItemNode(tailStart) && typeof tailStart.getValue === "function" ? tailStart.getValue() : 1;
+	const newTailList = cloneListTail(topListNode, tailStart, listStartValue);
+	logger.debug("branch: split-list-middle", {
+		hasNewTailList: Boolean(newTailList),
+		listStartValue,
+		tailStartType: tailStart.getType()
+	});
+	topListNode.insertAfter(sourceNode);
+	if (newTailList) sourceNode.insertAfter(newTailList);
+	if (topListNode.getChildrenSize() === 0) topListNode.remove();
+	if (!$isRootNode(sourceNode.getParent())) {
+		const parent = sourceNode.getParent();
+		if (parent && !$isRootNode(parent) && $isListItemNode(parent)) {
+			const parentList = getListParent(parent);
+			if (parentList && parentList.getChildrenSize() === 0) parentList.remove();
+		}
+	}
+	logger.debug("done: split-list-middle");
+};
+function registerBlockMoveCommand(editor) {
+	const unregister = editor.registerCommand(MOVE_BLOCK_COMMAND, (payload) => {
+		logger.debug("received-command", payload);
+		moveBlockNode(payload);
+		return true;
+	}, COMMAND_PRIORITY_EDITOR);
+	return () => {
+		unregister();
+	};
+}
+//#endregion
+export { MOVE_BLOCK_COMMAND, registerBlockMoveCommand };

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

@@ -0,0 +1,5 @@
+import { BlockMovePayload, MOVE_BLOCK_COMMAND, registerBlockMoveCommand } from "./command/index.js";
+import { BlockPlugin, BlockPluginOptions } from "./plugin/index.js";
+import { BlockDragTarget } from "./react/core/types.js";
+import { BlockMenuService, IBlockActionButton, IBlockActionButtonIcon, IBlockMenuItem, IBlockMenuRenderContext, IBlockMenuService } from "./service/i-block-menu-service.js";
+import { ReactBlockPlugin, ReactBlockPluginProps } from "./react/ReactBlockPlugin.js";

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

@@ -0,0 +1,9 @@
+import { IEditorPluginConstructor } from "../../../types/kernel.js";
+//#region src/plugins/block/plugin/index.d.ts
+interface BlockPluginOptions {
+  attributeName?: string;
+  className?: string;
+}
+declare const BlockPlugin: IEditorPluginConstructor<BlockPluginOptions>;
+//#endregion
+export { BlockPlugin, BlockPluginOptions };

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

@@ -0,0 +1,86 @@
+import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
+import { registerBlockMoveCommand } from "../command/index.js";
+import { BlockMenuService, IBlockMenuService } from "../service/i-block-menu-service.js";
+import { $getNodeByKey, ParagraphNode } from "lexical";
+//#region src/plugins/block/plugin/index.ts
+init_plugin();
+const PATCHED_NODE_TYPES = /* @__PURE__ */ new Set();
+const resolveNodeClass = (node) => {
+	if (typeof node === "function") return node;
+	if (typeof node === "object" && node && typeof node.replace === "function") return node.replace;
+	return null;
+};
+const patchBlockNodeCreateDOM = (nodeClass, attributeName) => {
+	const type = nodeClass.getType?.();
+	if (!type || PATCHED_NODE_TYPES.has(type)) return;
+	const originCreateDOM = nodeClass.prototype.createDOM;
+	if (typeof originCreateDOM !== "function") return;
+	nodeClass.prototype.createDOM = function patchedCreateDOM(config, editor) {
+		const dom = originCreateDOM.call(this, config, editor);
+		const latestNode = typeof this.getLatest === "function" ? this.getLatest() : this;
+		const isRootOrListChainToRoot = (() => {
+			let current = typeof latestNode.getParent === "function" ? latestNode.getParent() : null;
+			if (!current || typeof current.getType !== "function") return false;
+			if (current.getType() === "root") return true;
+			while (current && typeof current.getType === "function") {
+				const parentType = current.getType();
+				if (parentType === "root") return true;
+				if (parentType !== "list" && parentType !== "listitem") return false;
+				current = typeof current.getParent === "function" ? current.getParent() : null;
+			}
+			return false;
+		})();
+		const nodeKey = typeof latestNode.getKey === "function" ? latestNode.getKey() : this.getKey();
+		const nodeType = typeof latestNode.getType === "function" ? latestNode.getType() : "";
+		if (dom && typeof latestNode.isInline === "function" && !latestNode.isInline() && nodeType !== "list" && isRootOrListChainToRoot) {
+			dom.dataset.blockId = nodeKey;
+			if (attributeName !== "data-block-id") dom.setAttribute(attributeName, nodeKey);
+		}
+		return dom;
+	};
+	PATCHED_NODE_TYPES.add(type);
+};
+const BlockPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "BlockPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		const attributeName = config?.attributeName || "data-block-id";
+		const rootClassName = config?.className?.trim();
+		kernel.registerServiceHotReload(IBlockMenuService, new BlockMenuService());
+		if (rootClassName) this.registerRootClassName(kernel, rootClassName);
+		patchBlockNodeCreateDOM(ParagraphNode, attributeName);
+		this.registerNodeTransform(kernel, (node) => {
+			const nodeClass = resolveNodeClass(node);
+			if (!nodeClass) return node;
+			patchBlockNodeCreateDOM(nodeClass, attributeName);
+			return node;
+		});
+	}
+	onInit(editor) {
+		const blockMenuService = this.kernel.requireService(IBlockMenuService);
+		if (blockMenuService) {
+			const unregisterDeleteMenu = blockMenuService.registerMenu({
+				key: "__block_default_delete",
+				label: (context) => context.editor.t("block.delete"),
+				onClick: (context) => {
+					const lexicalEditor = context.editor.getLexicalEditor();
+					if (!lexicalEditor) return;
+					lexicalEditor.update(() => {
+						const target = $getNodeByKey(context.blockId);
+						if (!target) return;
+						target.remove();
+					});
+				},
+				order: 999
+			});
+			this.register(unregisterDeleteMenu);
+		}
+		this.register(registerBlockMoveCommand(editor));
+	}
+};
+//#endregion
+export { BlockPlugin };

package/es/plugins/block/react/ReactBlockPlugin.d.ts

@@ -0,0 +1,18 @@
+import { ILocaleKeys } from "../../../types/locale.js";
+import { BlockPluginOptions } from "../plugin/index.js";
+import { BlockDragTarget } from "./core/types.js";
+import { IBlockMenuRenderContext } from "../service/i-block-menu-service.js";
+import { FC } from "react";
+
+//#region src/plugins/block/react/ReactBlockPlugin.d.ts
+interface ReactBlockPluginProps extends Omit<BlockPluginOptions, 'className'> {
+  className?: string;
+  locale?: Partial<Record<keyof ILocaleKeys, string>>;
+  onDragTargetChange?: (target: BlockDragTarget | null) => void;
+  onDragTargetResolve?: (target: BlockDragTarget | null) => void;
+  onHoverBlockChange?: (context: IBlockMenuRenderContext | null) => void;
+  rootClassName?: string;
+}
+declare const ReactBlockPlugin: FC<ReactBlockPluginProps>;
+//#endregion
+export { ReactBlockPlugin, ReactBlockPluginProps };