@lobehub/editor 4.15.1 → 4.15.2

package/es/plugins/block/react/drag/drag-session.js

@@ -0,0 +1,264 @@
+import { createDebugLogger, init_debug } from "../../../../utils/debug.js";
+import { MOVE_BLOCK_COMMAND } from "../../command/index.js";
+import { collectDragBlocks, getAutoScrollDelta, resolveNearestInsertionSlot, resolveScrollContainers } from "./drag-utils.js";
+//#region src/plugins/block/react/drag/drag-session.ts
+init_debug();
+const logger = createDebugLogger("plugin", "block-react");
+const DRAG_GHOST_OFFSET_X = 14;
+const DRAG_GHOST_OFFSET_Y = 14;
+const DRAG_SOURCE_OPACITY = "0.45";
+const LIST_ITEM_GHOST_PADDING_INLINE_START = 24;
+const createDragGhostContent = (sourceBlock, clone) => {
+	if (sourceBlock.tagName !== "LI") return clone;
+	const list = sourceBlock.parentElement;
+	if (!list || list.tagName !== "UL" && list.tagName !== "OL") return clone;
+	const listClone = list.cloneNode(false);
+	listClone.style.margin = "0";
+	listClone.style.paddingInlineStart = `${LIST_ITEM_GHOST_PADDING_INLINE_START}px`;
+	listClone.style.pointerEvents = "none";
+	listClone.style.width = `calc(100% - ${LIST_ITEM_GHOST_PADDING_INLINE_START}px)`;
+	listClone.append(clone);
+	return listClone;
+};
+const createDragGhost = (sourceBlock, x, y, container) => {
+	const rect = sourceBlock.getBoundingClientRect();
+	const ghost = document.createElement("div");
+	const clone = sourceBlock.cloneNode(true);
+	ghost.dataset.blockDragGhost = "true";
+	ghost.setAttribute("aria-hidden", "true");
+	ghost.style.position = "fixed";
+	ghost.style.top = "0";
+	ghost.style.left = "0";
+	ghost.style.pointerEvents = "none";
+	ghost.style.zIndex = "10001";
+	ghost.style.opacity = "0.5";
+	ghost.style.width = `${rect.width}px`;
+	ghost.style.height = `${rect.height}px`;
+	ghost.style.overflow = "hidden";
+	ghost.style.borderRadius = "8px";
+	ghost.style.boxShadow = "0 10px 30px rgba(0, 0, 0, 0.12), 0 0 0 1px var(--lobe-color-border-secondary, rgba(0, 0, 0, 0.06)) inset";
+	ghost.style.transform = `translate3d(${x + DRAG_GHOST_OFFSET_X}px, ${y + DRAG_GHOST_OFFSET_Y}px, 0)`;
+	clone.style.margin = "0";
+	clone.style.pointerEvents = "none";
+	clone.style.width = "100%";
+	clone.style.height = "100%";
+	clone.setAttribute("contenteditable", "false");
+	clone.querySelectorAll("[contenteditable]").forEach((element) => {
+		element.setAttribute("contenteditable", "false");
+	});
+	ghost.append(createDragGhostContent(sourceBlock, clone));
+	(container || document.body).append(ghost);
+	return ghost;
+};
+const updateDragGhostPosition = (ghost, x, y) => {
+	ghost.style.transform = `translate3d(${x + DRAG_GHOST_OFFSET_X}px, ${y + DRAG_GHOST_OFFSET_Y}px, 0)`;
+};
+const removeDragGhost = (ghost) => {
+	if (!ghost) return;
+	ghost.remove();
+};
+const applyDragSourceOpacity = (sourceBlock) => {
+	const previousOpacity = sourceBlock.style.opacity;
+	sourceBlock.style.opacity = DRAG_SOURCE_OPACITY;
+	return () => {
+		sourceBlock.style.opacity = previousOpacity;
+	};
+};
+const startBlockDragSession = ({ clientX, clientY, clearDragPreview, contextRef, dragGhostContainer, editor, menuContext, onDraggingChange, onDragTargetResolve, setDragIndicator, setOperationMenuContext, setOperationMenuOpen, toggleOperationMenu }) => {
+	setOperationMenuOpen(false);
+	let dragGhost = null;
+	let restoreSourceOpacity = null;
+	contextRef.current.dragStartPoint = {
+		x: clientX,
+		y: clientY
+	};
+	contextRef.current.dragStarted = false;
+	contextRef.current.dragMoved = false;
+	contextRef.current.dragCleanup?.();
+	contextRef.current.dragCleanup = null;
+	if (contextRef.current.hideTimer !== null) {
+		window.clearTimeout(contextRef.current.hideTimer);
+		contextRef.current.hideTimer = null;
+	}
+	contextRef.current.draggingSource = {
+		blockElement: menuContext.blockElement,
+		blockId: menuContext.blockId
+	};
+	contextRef.current.dragPointerY = clientY;
+	contextRef.current.dragBlocks = collectDragBlocks(editor.getRootElement());
+	const refreshDragBlocksSnapshot = () => {
+		if (!contextRef.current.draggingSource) return;
+		contextRef.current.dragBlocks = collectDragBlocks(editor.getRootElement());
+	};
+	const updateDragPreview = (y) => {
+		const source = contextRef.current.draggingSource;
+		const blocks = contextRef.current.dragBlocks;
+		if (!source || blocks.length === 0) {
+			clearDragPreview();
+			return;
+		}
+		const bestSlot = resolveNearestInsertionSlot(source.blockId, blocks, y);
+		if (!bestSlot) {
+			clearDragPreview();
+			return;
+		}
+		contextRef.current.dragTarget = {
+			placement: bestSlot.placement,
+			sourceBlockId: bestSlot.sourceBlockId,
+			targetBlockId: bestSlot.targetBlockId
+		};
+		setDragIndicator({
+			left: bestSlot.left,
+			top: bestSlot.y,
+			width: bestSlot.width
+		});
+	};
+	const scrollContainers = resolveScrollContainers(editor.getRootElement());
+	const onPointerMove = (pointerEvent) => {
+		contextRef.current.dragPointerY = pointerEvent.clientY;
+		if (!contextRef.current.dragStarted && contextRef.current.dragStartPoint) {
+			if (Math.hypot(pointerEvent.clientX - contextRef.current.dragStartPoint.x, pointerEvent.clientY - contextRef.current.dragStartPoint.y) >= 10) {
+				contextRef.current.dragStarted = true;
+				contextRef.current.dragMoved = true;
+				contextRef.current.ignoreNextHandleClick = true;
+				onDraggingChange?.(true);
+				setOperationMenuOpen(false);
+				setOperationMenuContext(null);
+				if (!dragGhost && contextRef.current.draggingSource) {
+					dragGhost = createDragGhost(contextRef.current.draggingSource.blockElement, pointerEvent.clientX, pointerEvent.clientY, dragGhostContainer || editor.getRootElement()?.parentElement);
+					if (!restoreSourceOpacity) restoreSourceOpacity = applyDragSourceOpacity(contextRef.current.draggingSource.blockElement);
+				}
+			}
+		}
+		if (!contextRef.current.dragStarted) return;
+		if (dragGhost) updateDragGhostPosition(dragGhost, pointerEvent.clientX, pointerEvent.clientY);
+		if (contextRef.current.dragRaf !== null) return;
+		contextRef.current.dragRaf = window.requestAnimationFrame(() => {
+			contextRef.current.dragRaf = null;
+			if (contextRef.current.dragPointerY === null) {
+				clearDragPreview();
+				return;
+			}
+			updateDragPreview(contextRef.current.dragPointerY);
+		});
+	};
+	const onViewportChange = () => {
+		refreshDragBlocksSnapshot();
+		if (contextRef.current.dragPointerY !== null) updateDragPreview(contextRef.current.dragPointerY);
+	};
+	const onPointerUp = () => {
+		if (!contextRef.current.dragStarted && !contextRef.current.dragMoved) {
+			toggleOperationMenu(menuContext);
+			contextRef.current.ignoreNextHandleClick = true;
+			contextRef.current.draggingSource = null;
+			contextRef.current.dragPointerY = null;
+			contextRef.current.dragBlocks = [];
+			contextRef.current.dragStartPoint = null;
+			removeDragGhost(dragGhost);
+			dragGhost = null;
+			restoreSourceOpacity?.();
+			restoreSourceOpacity = null;
+			onDraggingChange?.(false);
+			window.removeEventListener("pointermove", onPointerMove, true);
+			window.removeEventListener("pointerup", onPointerUp, true);
+			window.removeEventListener("resize", onViewportChange);
+			document.removeEventListener("scroll", onViewportChange, true);
+			contextRef.current.dragCleanup = null;
+			return;
+		}
+		const finalTarget = contextRef.current.dragTarget;
+		if (finalTarget) {
+			logger.debug("drag-end", {
+				位置: finalTarget.placement === "before" ? "上方" : "下方",
+				位置节点id: finalTarget.targetBlockId,
+				插入节点id: finalTarget.sourceBlockId
+			});
+			const handled = editor.dispatchCommand(MOVE_BLOCK_COMMAND, finalTarget);
+			logger.debug("move-block-command-handled", handled);
+		}
+		onDragTargetResolve?.(contextRef.current.dragTarget);
+		if (contextRef.current.dragRaf !== null) {
+			window.cancelAnimationFrame(contextRef.current.dragRaf);
+			contextRef.current.dragRaf = null;
+		}
+		if (contextRef.current.dragAutoScrollRaf !== null) {
+			window.cancelAnimationFrame(contextRef.current.dragAutoScrollRaf);
+			contextRef.current.dragAutoScrollRaf = null;
+		}
+		contextRef.current.draggingSource = null;
+		contextRef.current.dragPointerY = null;
+		contextRef.current.dragBlocks = [];
+		contextRef.current.dragStartPoint = null;
+		removeDragGhost(dragGhost);
+		dragGhost = null;
+		restoreSourceOpacity?.();
+		restoreSourceOpacity = null;
+		onDraggingChange?.(false);
+		clearDragPreview();
+		window.removeEventListener("pointermove", onPointerMove, true);
+		window.removeEventListener("pointerup", onPointerUp, true);
+		window.removeEventListener("resize", onViewportChange);
+		document.removeEventListener("scroll", onViewportChange, true);
+		contextRef.current.dragCleanup = null;
+	};
+	window.addEventListener("pointermove", onPointerMove, true);
+	window.addEventListener("pointerup", onPointerUp, true);
+	window.addEventListener("resize", onViewportChange);
+	document.addEventListener("scroll", onViewportChange, true);
+	const runAutoScroll = () => {
+		contextRef.current.dragAutoScrollRaf = window.requestAnimationFrame(runAutoScroll);
+		if (!contextRef.current.draggingSource || contextRef.current.dragPointerY === null || !contextRef.current.dragStarted) return;
+		let didScroll = false;
+		for (const scrollContainer of scrollContainers) {
+			const delta = getAutoScrollDelta(contextRef.current.dragPointerY, scrollContainer);
+			if (delta === 0) continue;
+			const maxScrollTop = scrollContainer.scrollHeight - scrollContainer.clientHeight;
+			const nextScrollTop = Math.max(0, Math.min(maxScrollTop, scrollContainer.scrollTop + delta));
+			if (nextScrollTop === scrollContainer.scrollTop) continue;
+			scrollContainer.scrollTop = nextScrollTop;
+			didScroll = true;
+		}
+		if (didScroll) {
+			refreshDragBlocksSnapshot();
+			if (contextRef.current.dragPointerY !== null) updateDragPreview(contextRef.current.dragPointerY);
+			return;
+		}
+		const blocks = contextRef.current.dragBlocks;
+		if (blocks.length === 0) return;
+		const pointerY = contextRef.current.dragPointerY;
+		const nearBottom = pointerY > window.innerHeight - 80;
+		const nearTop = pointerY < 80;
+		const lastBlock = blocks[blocks.length - 1];
+		if (nearBottom) lastBlock.block.scrollIntoView({ block: "end" });
+		else if (nearTop) blocks[0].block.scrollIntoView({ block: "start" });
+		refreshDragBlocksSnapshot();
+		if (contextRef.current.dragPointerY !== null) updateDragPreview(contextRef.current.dragPointerY);
+	};
+	contextRef.current.dragAutoScrollRaf = window.requestAnimationFrame(runAutoScroll);
+	contextRef.current.dragCleanup = () => {
+		if (contextRef.current.dragRaf !== null) {
+			window.cancelAnimationFrame(contextRef.current.dragRaf);
+			contextRef.current.dragRaf = null;
+		}
+		if (contextRef.current.dragAutoScrollRaf !== null) {
+			window.cancelAnimationFrame(contextRef.current.dragAutoScrollRaf);
+			contextRef.current.dragAutoScrollRaf = null;
+		}
+		contextRef.current.draggingSource = null;
+		contextRef.current.dragPointerY = null;
+		contextRef.current.dragBlocks = [];
+		contextRef.current.dragStartPoint = null;
+		removeDragGhost(dragGhost);
+		dragGhost = null;
+		restoreSourceOpacity?.();
+		restoreSourceOpacity = null;
+		onDraggingChange?.(false);
+		clearDragPreview();
+		window.removeEventListener("pointermove", onPointerMove, true);
+		window.removeEventListener("pointerup", onPointerUp, true);
+		window.removeEventListener("resize", onViewportChange);
+		document.removeEventListener("scroll", onViewportChange, true);
+	};
+};
+//#endregion
+export { startBlockDragSession };

package/es/plugins/block/react/drag/drag-utils.js

@@ -0,0 +1,95 @@
+//#region src/plugins/block/react/drag/drag-utils.ts
+const collectDragBlocks = (root) => {
+	if (!root) return [];
+	return Array.from(root.querySelectorAll("[data-block-id]")).reduce((acc, block) => {
+		const blockId = block.dataset.blockId;
+		if (!blockId) return acc;
+		const rect = block.getBoundingClientRect();
+		if (rect.height <= 0) return acc;
+		acc.push({
+			block,
+			blockId,
+			rect: {
+				bottom: rect.bottom,
+				height: rect.height,
+				left: rect.left,
+				top: rect.top,
+				width: rect.width
+			}
+		});
+		return acc;
+	}, []).sort((a, b) => a.rect.top - b.rect.top);
+};
+const resolveScrollContainers = (root) => {
+	if (!root) return [];
+	let element = root;
+	const containers = [];
+	while (element) {
+		const overflowY = window.getComputedStyle(element).overflowY;
+		if ((overflowY === "auto" || overflowY === "scroll") && element.scrollHeight > element.clientHeight) containers.push(element);
+		element = element.parentElement;
+	}
+	const pageScroller = document.scrollingElement;
+	if (pageScroller && !containers.includes(pageScroller)) containers.push(pageScroller);
+	return containers;
+};
+const getAutoScrollDelta = (pointerY, container) => {
+	const isPageScroller = container === document.scrollingElement;
+	const top = isPageScroller ? 0 : container.getBoundingClientRect().top;
+	const bottom = isPageScroller ? window.innerHeight : container.getBoundingClientRect().bottom;
+	if (pointerY < top + 80) {
+		const ratio = (top + 80 - pointerY) / 80;
+		return -Math.max(1, Math.round(ratio * 18));
+	}
+	if (pointerY > bottom - 80) {
+		const ratio = (pointerY - (bottom - 80)) / 80;
+		return Math.max(1, Math.round(ratio * 18));
+	}
+	return 0;
+};
+const resolveNearestInsertionSlot = (sourceBlockId, blocks, y) => {
+	if (blocks.length === 0) return null;
+	const slots = [];
+	const first = blocks[0];
+	slots.push({
+		left: first.rect.left,
+		placement: "before",
+		sourceBlockId,
+		targetBlockId: first.blockId,
+		width: first.rect.width,
+		y: first.rect.top
+	});
+	for (let i = 0; i < blocks.length - 1; i++) {
+		const next = blocks[i + 1];
+		slots.push({
+			left: next.rect.left,
+			placement: "before",
+			sourceBlockId,
+			targetBlockId: next.blockId,
+			width: next.rect.width,
+			y: next.rect.top
+		});
+	}
+	const last = blocks[blocks.length - 1];
+	slots.push({
+		left: last.rect.left,
+		placement: "after",
+		sourceBlockId,
+		targetBlockId: last.blockId,
+		width: last.rect.width,
+		y: last.rect.bottom
+	});
+	let bestSlot = slots[0];
+	let bestDistance = Math.abs(y - bestSlot.y);
+	for (let i = 1; i < slots.length; i++) {
+		const slot = slots[i];
+		const distance = Math.abs(y - slot.y);
+		if (distance < bestDistance) {
+			bestSlot = slot;
+			bestDistance = distance;
+		}
+	}
+	return bestSlot;
+};
+//#endregion
+export { collectDragBlocks, getAutoScrollDelta, resolveNearestInsertionSlot, resolveScrollContainers };

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

@@ -0,0 +1,2 @@
+import { BlockDragTarget } from "./core/types.js";
+import { ReactBlockPlugin, ReactBlockPluginProps } from "./ReactBlockPlugin.js";

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

@@ -0,0 +1,66 @@
+import { createStaticStyles } from "antd-style";
+//#region src/plugins/block/react/style.ts
+const styles = createStaticStyles(({ css, cssVar }) => ({
+	dragHandle: css`
+    cursor: grab !important;
+
+    &:active {
+      cursor: grabbing !important;
+    }
+  `,
+	dragIndicator: css`
+    pointer-events: none;
+
+    position: fixed;
+    z-index: 10000;
+
+    height: 2px;
+    border-radius: 999px;
+
+    background: var(--lobe-color-primary, ${cssVar.colorPrimary});
+  `,
+	dragLayer: css`
+    pointer-events: none;
+
+    position: fixed;
+    z-index: 10001;
+    inset: 0;
+
+    overflow: visible;
+  `,
+	menu: css`
+    pointer-events: auto;
+    position: fixed;
+    z-index: 100;
+    transition:
+      inset-inline-start 200ms ease,
+      inset-block-start 200ms ease;
+  `,
+	menuInner: css`
+    display: flex;
+    gap: 4px;
+    align-items: center;
+
+    min-width: 28px;
+    min-height: 28px;
+    padding: 2px;
+    border-radius: 8px;
+
+    background: transparent;
+    box-shadow: none;
+
+    transition:
+      background 120ms ease,
+      box-shadow 120ms ease;
+
+    &:hover {
+      background: var(--lobe-color-fill-secondary, ${cssVar.colorFillSecondary});
+      box-shadow: 0 0 0 1px ${cssVar.colorBorderSecondary} inset;
+    }
+  `,
+	root: css`
+    padding-inline: 54px 54px;
+  `
+}));
+//#endregion
+export { styles };

package/es/plugins/block/service/i-block-menu-service.d.ts

@@ -0,0 +1,44 @@
+import { IEditor, IServiceID } from "../../../types/kernel.js";
+//#region src/plugins/block/service/i-block-menu-service.d.ts
+interface IBlockMenuRenderContext {
+  blockElement: HTMLElement;
+  blockId: string;
+  editor: IEditor;
+}
+interface IBlockMenuItem {
+  key: string;
+  label: string | ((context: IBlockMenuRenderContext) => string);
+  onClick: (context: IBlockMenuRenderContext) => void;
+  order?: number;
+  when?: (context: IBlockMenuRenderContext) => boolean;
+}
+type IBlockActionButtonIcon = 'plus';
+interface IBlockActionButton {
+  icon?: IBlockActionButtonIcon;
+  key: string;
+  onClick: (context: IBlockMenuRenderContext) => void;
+  order?: number;
+  title: string | ((context: IBlockMenuRenderContext) => string);
+  when?: (context: IBlockMenuRenderContext) => boolean;
+}
+interface IBlockMenuService {
+  getActionButtons(context: IBlockMenuRenderContext): IBlockActionButton[];
+  getMenus(context: IBlockMenuRenderContext): IBlockMenuItem[];
+  registerActionButton(item: IBlockActionButton): () => void;
+  registerMenu(item: IBlockMenuItem): () => void;
+  subscribe(listener: () => void): () => void;
+}
+declare const IBlockMenuService: IServiceID<IBlockMenuService>;
+declare class BlockMenuService implements IBlockMenuService {
+  private actionButtons;
+  private items;
+  private listeners;
+  getActionButtons(context: IBlockMenuRenderContext): IBlockActionButton[];
+  getMenus(context: IBlockMenuRenderContext): IBlockMenuItem[];
+  registerActionButton(item: IBlockActionButton): () => void;
+  registerMenu(item: IBlockMenuItem): () => void;
+  subscribe(listener: () => void): () => void;
+  private notify;
+}
+//#endregion
+export { BlockMenuService, IBlockActionButton, IBlockActionButtonIcon, IBlockMenuItem, IBlockMenuRenderContext, IBlockMenuService };

package/es/plugins/block/service/i-block-menu-service.js

@@ -0,0 +1,43 @@
+import { genServiceId } from "../../../editor-kernel/utils.js";
+//#region src/plugins/block/service/i-block-menu-service.ts
+const IBlockMenuService = genServiceId("BlockMenuService");
+var BlockMenuService = class {
+	constructor() {
+		this.actionButtons = /* @__PURE__ */ new Map();
+		this.items = /* @__PURE__ */ new Map();
+		this.listeners = /* @__PURE__ */ new Set();
+	}
+	getActionButtons(context) {
+		return Array.from(this.actionButtons.values()).filter((item) => item.when ? item.when(context) : true).sort((a, b) => (a.order || 0) - (b.order || 0));
+	}
+	getMenus(context) {
+		return Array.from(this.items.values()).filter((item) => item.when ? item.when(context) : true).sort((a, b) => (a.order || 0) - (b.order || 0));
+	}
+	registerActionButton(item) {
+		this.actionButtons.set(item.key, item);
+		this.notify();
+		return () => {
+			this.actionButtons.delete(item.key);
+			this.notify();
+		};
+	}
+	registerMenu(item) {
+		this.items.set(item.key, item);
+		this.notify();
+		return () => {
+			this.items.delete(item.key);
+			this.notify();
+		};
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	notify() {
+		for (const listener of this.listeners) listener();
+	}
+};
+//#endregion
+export { BlockMenuService, IBlockMenuService };

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

@@ -0,0 +1 @@
+import { BlockMenuService, IBlockActionButton, IBlockActionButtonIcon, IBlockMenuItem, IBlockMenuRenderContext, IBlockMenuService } from "./i-block-menu-service.js";

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

@@ -0,0 +1,7 @@
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/code/command/index.d.ts
+declare const INSERT_CODEINLINE_COMMAND: _$lexical.LexicalCommand<undefined>;
+//#endregion
+export { INSERT_CODEINLINE_COMMAND };

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

@@ -0,0 +1,30 @@
+import { $createCursorNode } from "../../common/node/cursor.js";
+import { $createCodeNode as $createCodeNode$1, $isCodeInlineNode, getCodeInlineNode } from "../node/code.js";
+import { $getSelection, $insertNodes, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+import { $isCodeHighlightNode } from "@lexical/code-core";
+//#region src/plugins/code/command/index.ts
+const INSERT_CODEINLINE_COMMAND = createCommand("INSERT_CODEINLINE_COMMAND");
+function registerCodeInlineCommand(editor) {
+	return editor.registerCommand(INSERT_CODEINLINE_COMMAND, () => {
+		editor.update(() => {
+			const selection = $getSelection();
+			if (!selection || !$isRangeSelection(selection)) return false;
+			const focusNode = selection.focus.getNode();
+			const anchorNode = selection.anchor.getNode();
+			if ($isCodeHighlightNode(focusNode) || $isCodeHighlightNode(anchorNode)) return false;
+			const code = getCodeInlineNode(focusNode);
+			if (code !== getCodeInlineNode(anchorNode)) return false;
+			if ($isCodeInlineNode(code)) {
+				for (const node of code.getChildren().slice(0)) code.insertBefore(node);
+				code.remove();
+				return true;
+			}
+			const codeNode = $createCodeNode$1(selection.getTextContent());
+			$insertNodes([codeNode, $createCursorNode()]);
+			codeNode.select();
+		});
+		return true;
+	}, COMMAND_PRIORITY_EDITOR);
+}
+//#endregion
+export { INSERT_CODEINLINE_COMMAND, registerCodeInlineCommand };

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

@@ -0,0 +1,3 @@
+import { INSERT_CODEINLINE_COMMAND } from "./command/index.js";
+import { CodePlugin } from "./plugin/index.js";
+import { ReactCodePlugin } from "./react/CodeReactPlugin.js";

package/es/plugins/code/node/code.js

@@ -0,0 +1,91 @@
+import { $createCursorNode, $isCursorNode, CardLikeElementNode } from "../../common/node/cursor.js";
+import { $applyNodeReplacement, $createTextNode, $getSelection, $isNodeSelection, $isRangeSelection } from "lexical";
+import { addClassNamesToElement } from "@lexical/utils";
+//#region src/plugins/code/node/code.ts
+var CodeNode = class CodeNode extends CardLikeElementNode {
+	static getType() {
+		return "codeInline";
+	}
+	static clone(node) {
+		return new CodeNode(node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createCodeNode().updateFromJSON(serializedNode);
+	}
+	createDOM(config) {
+		const element = document.createElement("span");
+		element.setAttribute("data-lexical-key", this.getKey());
+		const childContainer = document.createElement("ne-content");
+		element.append(childContainer);
+		addClassNamesToElement(element, config.theme.codeInline);
+		return element;
+	}
+	getDOMSlot(element) {
+		const neContent = element.querySelector("ne-content");
+		if (!neContent) throw new Error("CodeNode: ne-content not found");
+		return super.getDOMSlot(element).withElement(neContent);
+	}
+	canBeEmpty() {
+		return false;
+	}
+	isCardLike() {
+		return true;
+	}
+	isInline() {
+		return true;
+	}
+	canIndent() {
+		return false;
+	}
+	canInsertTextBefore() {
+		return true;
+	}
+	canInsertTextAfter() {
+		return true;
+	}
+	updateDOM(prevNode, dom, config) {
+		if ((prevNode ? prevNode : null) !== this) addClassNamesToElement(dom, config.theme.codeInline);
+		return false;
+	}
+};
+function $createCodeNode(textContent) {
+	const codeNode = $applyNodeReplacement(new CodeNode());
+	const cursorNode = $createCursorNode();
+	codeNode.append(cursorNode);
+	if (textContent) codeNode.append($createTextNode(textContent));
+	return codeNode;
+}
+function $isCodeInlineNode(node) {
+	return node instanceof CodeNode;
+}
+function getCodeInlineNode(node) {
+	if ($isCursorNode(node)) {
+		const parent = node.getParent();
+		if ($isCodeInlineNode(parent)) return parent;
+		if ($isCodeInlineNode(node.getNextSibling())) return node.getNextSibling();
+		if ($isCodeInlineNode(node.getPreviousSibling())) return node.getPreviousSibling();
+		return null;
+	}
+	if ($isCodeInlineNode(node.getParent())) return node.getParent();
+	return null;
+}
+function $isSelectionInCodeInline(editor) {
+	return editor.getEditorState().read(() => {
+		const selection = $getSelection();
+		if (!selection) return false;
+		if ($isRangeSelection(selection)) {
+			const focusNode = selection.focus.getNode();
+			const anchorNode = selection.anchor.getNode();
+			const code = getCodeInlineNode(focusNode);
+			if (code !== getCodeInlineNode(anchorNode)) return false;
+			if ($isCodeInlineNode(code)) return true;
+			return false;
+		} else if ($isNodeSelection(selection)) {
+			const nodes = selection.getNodes();
+			if (nodes.length === 1 && $isCodeInlineNode(nodes[0])) return true;
+		}
+		return false;
+	});
+}
+//#endregion
+export { $createCodeNode, $isCodeInlineNode, $isSelectionInCodeInline, CodeNode, getCodeInlineNode };

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

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