@lobehub/editor 4.24.1 → 4.25.0

package/es/plugins/common/plugin/progressive-select-all.js

@@ -0,0 +1,81 @@
+import { $computeTableMapSkipCellCheck, $createTableSelection, $isTableCellNode, $isTableNode, $isTableSelection } from "@lexical/table";
+import { $getNodeByKey, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $setSelection, COMMAND_PRIORITY_HIGH, SELECT_ALL_COMMAND } from "lexical";
+//#region src/plugins/common/plugin/progressive-select-all.ts
+const COLLAPSIBLE_NODE_TYPE = "collapsible";
+function registerProgressiveSelectAll(editor) {
+	return editor.registerCommand(SELECT_ALL_COMMAND, () => {
+		const selection = $getSelection();
+		if ($isTableSelection(selection)) return $expandTableSelection(selection);
+		if (!$isRangeSelection(selection)) return false;
+		const anchorCell = $findNearestNode(selection.anchor.getNode(), $isTableCellNode);
+		const focusCell = $findNearestNode(selection.focus.getNode(), $isTableCellNode);
+		if (anchorCell && focusCell && anchorCell.is(focusCell)) {
+			const table = $findNearestNode(anchorCell, $isTableNode);
+			if (table) {
+				const tableSelection = $createTableSelection();
+				tableSelection.set(table.getKey(), anchorCell.getKey(), anchorCell.getKey());
+				$setSelection(tableSelection);
+				return true;
+			}
+		}
+		const anchorCollapsible = $findCollapsibleAncestor(selection.anchor.getNode());
+		const focusCollapsible = $findCollapsibleAncestor(selection.focus.getNode());
+		if (!anchorCollapsible || !focusCollapsible || !anchorCollapsible.is(focusCollapsible)) return false;
+		if ($isEntireElementSelected(selection, anchorCollapsible)) $selectDocument();
+		else anchorCollapsible.select(0, anchorCollapsible.getChildrenSize());
+		return true;
+	}, COMMAND_PRIORITY_HIGH);
+}
+function $expandTableSelection(selection) {
+	const table = $getNodeByKey(selection.tableKey);
+	if (!$isTableNode(table)) return false;
+	const cells = $getTableCells(table);
+	if (!cells) return false;
+	const selectedCellKeys = new Set(selection.getNodes().filter($isTableCellNode).map((cell) => cell.getKey()));
+	if (cells.keys.every((key) => selectedCellKeys.has(key))) {
+		$selectDocument();
+		return true;
+	}
+	const tableSelection = $createTableSelection();
+	tableSelection.set(table.getKey(), cells.first.getKey(), cells.last.getKey());
+	$setSelection(tableSelection);
+	return true;
+}
+function $getTableCells(table) {
+	if (!$isTableNode(table)) return null;
+	const [tableMap] = $computeTableMapSkipCellCheck(table, null, null);
+	const entries = tableMap.flat().filter(Boolean);
+	const first = entries[0]?.cell;
+	const last = entries.at(-1)?.cell;
+	if (!first || !last) return null;
+	return {
+		first,
+		keys: Array.from(new Set(entries.map(({ cell }) => cell.getKey()))),
+		last
+	};
+}
+function $findNearestNode(node, predicate) {
+	let current = node;
+	while (current) {
+		if (predicate(current)) return current;
+		current = current.getParent();
+	}
+	return null;
+}
+function $findCollapsibleAncestor(node) {
+	return $findNearestNode(node, (candidate) => $isElementNode(candidate) && candidate.getType() === COLLAPSIBLE_NODE_TYPE);
+}
+function $isEntireElementSelected(selection, element) {
+	const startOffset = 0;
+	const endOffset = element.getChildrenSize();
+	return $isPointAt(selection.anchor, element, startOffset) && $isPointAt(selection.focus, element, endOffset) || $isPointAt(selection.focus, element, startOffset) && $isPointAt(selection.anchor, element, endOffset);
+}
+function $isPointAt(point, element, offset) {
+	return point.key === element.getKey() && point.offset === offset && point.type === "element";
+}
+function $selectDocument() {
+	const root = $getRoot();
+	root.select(0, root.getChildrenSize());
+}
+//#endregion
+export { registerProgressiveSelectAll };

package/es/plugins/common/plugin/register.js

@@ -2,8 +2,9 @@ import { createDebugLogger, init_debug } from "../../../utils/debug.js";
 import { HotkeyEnum, init_hotkey } from "../../../types/hotkey.js";
 import { $closest, init_utils } from "../../../editor-kernel/utils.js";
 import { $createNodeSelection, $createParagraphNode, $getRoot, $getSelection, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, FORMAT_TEXT_COMMAND, HISTORIC_TAG, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, REDO_COMMAND, UNDO_COMMAND } from "lexical";
-import { $isHeadingNode, QuoteNode } from "@lexical/rich-text";
+import { $isHeadingNode, $isQuoteNode, QuoteNode } from "@lexical/rich-text";
 import { mergeRegister } from "@lexical/utils";
+import { $isListItemNode, $isListNode } from "@lexical/list";
 import { $isCodeHighlightNode, $isCodeNode } from "@lexical/code-core";
 //#region src/plugins/common/plugin/register.ts
 init_utils();
@@ -23,7 +24,9 @@ function resolveElement(element, isBackward, focusOffset) {
 			block = parent;
 		}
 	}
-	return block.getChildAtIndex(isBackward ? offset - 1 : offset);
+	const childIndex = isBackward ? offset - 1 : offset;
+	if (childIndex < 0 || childIndex >= block.getChildrenSize()) return null;
+	return block.getChildAtIndex(childIndex);
 }
 function isCodeNodeLastLine(focusNode) {
 	if (!$isCodeHighlightNode(focusNode)) return false;
@@ -68,7 +71,55 @@ function $isSelectionAtEndOfRoot(selection) {
 	const focus = selection.focus;
 	return focus.key === "root" && focus.offset === $getRoot().getChildrenSize();
 }
-function registerHeaderBackspace(editor) {
+function $isSelectionInList(selection) {
+	return Boolean($closest(selection.focus.getNode(), (node) => $isListNode(node) || $isListItemNode(node)));
+}
+function $getLeadingQuoteNode(selection) {
+	const anchor = selection.anchor;
+	if (anchor.offset !== 0) return false;
+	let node = anchor.getNode();
+	let current = node;
+	let quoteNode = null;
+	while (current) {
+		if ($isQuoteNode(current)) {
+			quoteNode = current;
+			break;
+		}
+		current = current.getParent();
+	}
+	if (!quoteNode) return false;
+	while (node !== quoteNode) {
+		if (node.getIndexWithinParent() !== 0) return false;
+		const parent = node.getParent();
+		if (!parent) return false;
+		node = parent;
+	}
+	return quoteNode;
+}
+function $unwrapQuoteNode(quoteNode) {
+	const children = quoteNode.getChildren();
+	if (children.length === 0) {
+		const paragraphNode = $createParagraphNode();
+		quoteNode.replace(paragraphNode);
+		paragraphNode.select(0, 0);
+		return;
+	}
+	let firstNode = null;
+	for (const child of children) {
+		if ($isElementNode(child)) {
+			quoteNode.insertBefore(child);
+			firstNode ||= child;
+			continue;
+		}
+		const paragraphNode = $createParagraphNode();
+		paragraphNode.append(child);
+		quoteNode.insertBefore(paragraphNode);
+		firstNode ||= paragraphNode;
+	}
+	quoteNode.remove();
+	if ($isElementNode(firstNode)) firstNode.select(0, 0);
+}
+function registerBlockBackspace(editor) {
 	return editor.registerCommand(KEY_BACKSPACE_COMMAND, (payload) => {
 		const headingNode = editor.getEditorState().read(() => {
 			const selection = $getSelection();
@@ -96,6 +147,22 @@ function registerHeaderBackspace(editor) {
 			});
 			return true;
 		}
+		if (editor.getEditorState().read(() => {
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection) || !selection.isCollapsed()) return false;
+			return $getLeadingQuoteNode(selection);
+		})) {
+			payload.stopImmediatePropagation();
+			payload.preventDefault();
+			payload.stopPropagation();
+			editor.update(() => {
+				const selection = $getSelection();
+				if (!$isRangeSelection(selection) || !selection.isCollapsed()) return;
+				const leadingQuoteNode = $getLeadingQuoteNode(selection);
+				if (leadingQuoteNode) $unwrapQuoteNode(leadingQuoteNode);
+			});
+			return true;
+		}
 		return false;
 	}, COMMAND_PRIORITY_NORMAL);
 }
@@ -150,6 +217,7 @@ function registerRichKeydown(editor, kernel, options) {
 				return true;
 			}
 		} else if ($isRangeSelection(selection)) {
+			if ($isSelectionInList(selection)) return false;
 			const possibleNode = $getAdjacentNode(selection.focus, true);
 			const upblock = possibleNode || $getDownUpNode(selection.focus, true);
 			if (!event.shiftKey && $isDecoratorNode(possibleNode)) {
@@ -219,6 +287,7 @@ function registerRichKeydown(editor, kernel, options) {
 				event.preventDefault();
 				return true;
 			}
+			if ($isSelectionInList(selection)) return false;
 			const possibleNode = $getAdjacentNode(selection.focus, false);
 			const upblock = possibleNode || $getDownUpNode(selection.focus, false);
 			if (!event.shiftKey && $isDecoratorNode(possibleNode)) {
@@ -304,4 +373,4 @@ function registerLastElement(editor) {
 	});
 }
 //#endregion
-export { $getAdjacentNode, $getDownUpNode, registerHeaderBackspace, registerLastElement, registerRichKeydown };
+export { $getAdjacentNode, $getDownUpNode, registerBlockBackspace, registerLastElement, registerRichKeydown };

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

@@ -1,9 +1,10 @@
-import { $createLinkNode } from "../node/LinkNode.js";
-import { $createTextNode, $getNodeByKey, $insertNodes, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+import { $createLinkNode, $isLinkNode, TOGGLE_LINK_COMMAND } from "../node/LinkNode.js";
+import { $createRangeSelection, $createTextNode, $getNodeByKey, $getSelection, $insertNodes, $isRangeSelection, $isTextNode, $setSelection, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
 import { mergeRegister } from "@lexical/utils";
 //#region src/plugins/link/command/index.ts
 const INSERT_LINK_COMMAND = createCommand("INSERT_LINK_COMMAND");
 const UPDATE_LINK_TEXT_COMMAND = createCommand("UPDATE_LINK_TEXT_COMMAND");
+const UNLINK_LINK_COMMAND = createCommand("UNLINK_LINK_COMMAND");
 function registerLinkCommand(editor) {
 	return mergeRegister(editor.registerCommand(INSERT_LINK_COMMAND, (payload) => {
 		const { url, title = url } = payload;
@@ -27,7 +28,29 @@ function registerLinkCommand(editor) {
 			}
 		});
 		return false;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(UNLINK_LINK_COMMAND, ({ key }) => {
+		editor.update(() => {
+			const node = $getNodeByKey(key);
+			if (!$isLinkNode(node)) return;
+			let selection = $getSelection();
+			if (!selection || !$isRangeSelection(selection)) {
+				$setSelection($createRangeSelection());
+				selection = $getSelection();
+			}
+			const first = node.getFirstDescendant();
+			const last = node.getLastDescendant();
+			if (selection && $isRangeSelection(selection) && $isTextNode(first) && $isTextNode(last)) {
+				selection.anchor.set(first.getKey(), 0, "text");
+				selection.focus.set(last.getKey(), last.getTextContentSize(), "text");
+				editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+				return;
+			}
+			const children = node.getChildren();
+			for (const child of children) node.insertBefore(child);
+			node.remove();
+		});
+		return true;
 	}, COMMAND_PRIORITY_EDITOR));
 }
 //#endregion
-export { INSERT_LINK_COMMAND, UPDATE_LINK_TEXT_COMMAND, registerLinkCommand };
+export { INSERT_LINK_COMMAND, UNLINK_LINK_COMMAND, UPDATE_LINK_TEXT_COMMAND, registerLinkCommand };

package/es/plugins/link/conversion/index.js

@@ -0,0 +1,237 @@
+import { getNodeTitle, getNodeUrl } from "../service/i-link-service.js";
+import { $createLinkNode, $isLinkNode } from "../node/LinkNode.js";
+import { $createLinkCardNode, $isLinkCardNode } from "../node/LinkCardNode.js";
+import { $createLinkBlockCardNode, $isLinkBlockCardNode } from "../node/LinkBlockCardNode.js";
+import { $createLinkIframeNode, $isLinkIframeNode } from "../node/LinkIframeNode.js";
+import { $createSchemaNode, $isSchemaNode } from "../node/SchemaNode.js";
+import { $createParagraphNode, $createTextNode, $getNodeByKey, $isParagraphNode, $isRootNode } from "lexical";
+//#region src/plugins/link/conversion/index.ts
+function getLinkToolbarCapabilities(node, editor, linkService) {
+	const url = getNodeUrl(node);
+	const title = getNodeTitle(node);
+	const context = createRuleContext(editor, title, title);
+	const embedRule = linkService?.getEmbedRule(url, context);
+	const schemaRule = $isLinkNode(node) && linkService?.getSchemaRule(url, {
+		...context,
+		schema: linkService.parseSchemaUrl(url)
+	});
+	return {
+		canConvertToBlockCard: $isLinkNode(node) && Boolean(embedRule?.allowBlockCard) || $isLinkCardNode(node) && !$isLinkBlockCardNode(node) || $isLinkIframeNode(node),
+		canConvertToCard: $isLinkNode(node) && Boolean(embedRule?.allowCard) || $isLinkIframeNode(node) || $isLinkBlockCardNode(node),
+		canConvertToIframe: $isLinkNode(node) && Boolean(embedRule?.allowIframe) || $isLinkCardNode(node),
+		canConvertToLink: !$isLinkNode(node),
+		canConvertToSchema: $isLinkNode(node) && Boolean(schemaRule)
+	};
+}
+function convertLinkToolbarNodeToLink(node) {
+	const url = getNodeUrl(node);
+	const title = getNodeTitle(node);
+	const linkNode = $createLinkNode(url, {
+		target: $isLinkCardNode(node) ? node.getOpenTarget() : null,
+		title
+	});
+	linkNode.append($createTextNode(title));
+	replaceWithInlineNode(node, linkNode);
+	return linkNode;
+}
+function convertLinkToolbarNodeByKeyToLink(editor, key) {
+	let replacementKey = null;
+	editor.update(() => {
+		const node = $getNodeByKey(key);
+		if (!$isLinkToolbarNode(node)) return;
+		const linkNode = convertLinkToolbarNodeToLink(node);
+		replacementKey = linkNode.getKey();
+		linkNode.selectEnd();
+	}, { discrete: true });
+	return replacementKey;
+}
+function convertLinkNodeToSchema(node, editor, linkService) {
+	const url = node.getURL();
+	const title = node.getTitle() || node.getTextContent() || url;
+	const schema = linkService.parseSchemaUrl(url);
+	const rule = linkService.getSchemaRule(url, {
+		...createRuleContext(editor, node.getTextContent(), title),
+		schema
+	});
+	if (!rule) return null;
+	const parsed = rule.parse?.(url, schema);
+	const payload = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? normalizeSchemaPayload(parsed) : { payload: parsed };
+	const schemaNode = $createSchemaNode({
+		payload: payload.payload,
+		schemaType: payload.schemaType || rule.id,
+		title: payload.title || title,
+		url: payload.url || url
+	});
+	node.replace(schemaNode);
+	return schemaNode;
+}
+function convertLinkNodeByKeyToSchema(editor, key, linkService) {
+	editor.update(() => {
+		const node = $getNodeByKey(key);
+		if (!$isLinkNode(node)) return;
+		convertLinkNodeToSchema(node, editor, linkService)?.selectNext();
+	}, { discrete: true });
+}
+function replaceWithResolvedCardNode(node, payload, fallback, layout) {
+	const cardPayload = {
+		description: payload?.description,
+		icon: payload?.icon,
+		openTarget: payload?.openTarget || ($isLinkNode(node) ? node.getTarget() : $isLinkCardNode(node) ? node.getOpenTarget() : null) || "_blank",
+		title: payload?.title || fallback.title,
+		url: payload?.url || fallback.url
+	};
+	const cardNode = layout === "block" ? $createLinkBlockCardNode(cardPayload) : $createLinkCardNode(cardPayload);
+	if (layout === "block") replaceWithBlockNode(node, cardNode);
+	else replaceWithInlineNode(node, cardNode);
+	return cardNode;
+}
+async function replaceNodeByKeyWithCardNode(editor, key, linkService, layout = "inline") {
+	let request;
+	editor.getEditorState().read(() => {
+		const node = $getNodeByKey(key);
+		if (!$isLinkNode(node) && !$isLinkCardNode(node) && !$isLinkIframeNode(node)) return;
+		const url = getNodeUrl(node);
+		const title = getNodeTitle(node);
+		const context = createRuleContext(editor, title, title);
+		const rule = linkService.getEmbedRule(url, context);
+		let payload;
+		try {
+			payload = $isLinkCardNode(node) ? getExistingCardPayload(node) : rule?.getCardPayload?.(url, context);
+		} catch {
+			payload = void 0;
+		}
+		request = {
+			payload,
+			title,
+			url
+		};
+	});
+	if (!request) return;
+	const resolvedRequest = request;
+	let replacementKey = null;
+	const replaceCurrentNode = (payload) => {
+		const node = $getNodeByKey(key);
+		if (!$isLinkNode(node) && !$isLinkCardNode(node) && !$isLinkIframeNode(node)) return;
+		if (getNodeUrl(node) !== resolvedRequest.url) return;
+		const replacement = replaceWithResolvedCardNode(node, payload, resolvedRequest, layout);
+		replacementKey = replacement.getKey();
+		replacement.selectNext();
+	};
+	const initialPayload = resolvedRequest.payload;
+	if (!isPromiseLike(initialPayload)) {
+		editor.update(() => replaceCurrentNode(initialPayload), { discrete: true });
+		return;
+	}
+	editor.update(() => replaceCurrentNode(void 0), { discrete: true });
+	if (!replacementKey) return;
+	const cardKey = replacementKey;
+	linkService.setCardMetadataLoading(cardKey, true);
+	try {
+		const resolvedPayload = await initialPayload;
+		if (!resolvedPayload) return;
+		editor.update(() => {
+			const cardNode = $getNodeByKey(cardKey);
+			if (!$isLinkCardNode(cardNode) || getNodeUrl(cardNode) !== resolvedRequest.url) return;
+			cardNode.setURL(resolvedPayload.url || resolvedRequest.url).setTitle(resolvedPayload.title || resolvedRequest.title).setIcon(resolvedPayload.icon).setDescription(resolvedPayload.description).setOpenTarget(resolvedPayload.openTarget || cardNode.getOpenTarget() || "_blank");
+		}, { discrete: true });
+	} catch {
+		return;
+	} finally {
+		linkService.setCardMetadataLoading(cardKey, false);
+	}
+}
+function replaceNodeByKeyWithBlockCardNode(editor, key, linkService) {
+	return replaceNodeByKeyWithCardNode(editor, key, linkService, "block");
+}
+function replaceWithIframeNode(node, editor, linkService) {
+	const url = getNodeUrl(node);
+	const title = getNodeTitle(node);
+	const context = createRuleContext(editor, title, title);
+	const payload = linkService.getEmbedRule(url, context)?.getIframePayload?.(url, context);
+	const iframeNode = $createLinkIframeNode({
+		src: payload?.src || url,
+		title: payload?.title || title,
+		url: payload?.url || url
+	});
+	replaceWithBlockIframeNode(node, iframeNode);
+	return iframeNode;
+}
+function replaceNodeByKeyWithIframeNode(editor, key, linkService) {
+	editor.update(() => {
+		const node = $getNodeByKey(key);
+		if (!$isLinkNode(node) && !$isLinkCardNode(node)) return;
+		replaceWithIframeNode(node, editor, linkService).selectNext();
+	}, { discrete: true });
+}
+function replaceWithInlineNode(node, inlineNode) {
+	if (node.isInline()) {
+		node.replace(inlineNode);
+		return;
+	}
+	const paragraph = $createParagraphNode();
+	paragraph.append(inlineNode);
+	node.replace(paragraph);
+}
+function replaceWithBlockIframeNode(node, iframeNode) {
+	replaceWithBlockNode(node, iframeNode);
+}
+function replaceWithBlockNode(node, blockNode) {
+	const parent = node.getParent();
+	if (parent && !$isRootNode(parent) && !parent.isInline() && parent.getChildrenSize() === 1) {
+		parent.replace(blockNode);
+		return;
+	}
+	if (parent && $isParagraphNode(parent)) {
+		const previousSiblings = node.getPreviousSiblings();
+		const nextSiblings = node.getNextSiblings();
+		if (previousSiblings.length === 0) {
+			parent.insertBefore(blockNode);
+			node.remove();
+			if (parent.getChildrenSize() === 0) parent.remove();
+			return;
+		}
+		if (nextSiblings.length === 0) {
+			parent.insertAfter(blockNode);
+			node.remove();
+			return;
+		}
+		const nextParagraph = $createParagraphNode();
+		nextParagraph.setFormat(parent.getFormatType());
+		nextParagraph.setIndent(parent.getIndent());
+		nextParagraph.setDirection(parent.getDirection());
+		nextParagraph.append(...nextSiblings);
+		parent.insertAfter(blockNode);
+		blockNode.insertAfter(nextParagraph);
+		node.remove();
+		return;
+	}
+	node.replace(blockNode);
+}
+function $isLinkToolbarNode(node) {
+	return $isLinkNode(node) || $isLinkCardNode(node) || $isLinkIframeNode(node) || $isSchemaNode(node);
+}
+function createRuleContext(editor, text, title) {
+	return {
+		editor,
+		text,
+		title
+	};
+}
+function isPromiseLike(value) {
+	return Boolean(value && typeof value.then === "function");
+}
+function getExistingCardPayload(node) {
+	return {
+		description: node.getDescription(),
+		icon: node.getIcon(),
+		openTarget: node.getOpenTarget(),
+		title: node.getTitle(),
+		url: node.getURL()
+	};
+}
+function normalizeSchemaPayload(payload) {
+	if ("payload" in payload || "schemaType" in payload || "title" in payload || "url" in payload) return payload;
+	return { payload };
+}
+//#endregion
+export { $isLinkToolbarNode, convertLinkNodeByKeyToSchema, convertLinkNodeToSchema, convertLinkToolbarNodeByKeyToLink, convertLinkToolbarNodeToLink, getLinkToolbarCapabilities, replaceNodeByKeyWithBlockCardNode, replaceNodeByKeyWithCardNode, replaceNodeByKeyWithIframeNode, replaceWithBlockIframeNode, replaceWithBlockNode, replaceWithIframeNode, replaceWithInlineNode };

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

@@ -1,7 +1,9 @@
 import { INSERT_LINK_COMMAND } from "./command/index.js";
+import { ILinkService, LinkEmbedRule, LinkLabels, LinkToolbarAction, LinkToolbarItem, LinkToolbarItemIcon, LinkToolbarRenderContext, ParsedSchemaUrl, SchemaRule, getNodeTitle, getNodeUrl, normalizeProtocol } from "./service/i-link-service.js";
+import { normalizeSchemaLinkNode } from "./normalization/index.js";
 import { LinkPlugin, LinkPluginOptions } from "./plugin/index.js";
-import { ReactLinkPluginProps } from "./react/type.js";
+import { LinkCardRenderer, LinkCardRendererProps, LinkIframeRenderer, LinkIframeRendererProps, ReactSchemaRule, SchemaLinkRenderer, SchemaLinkRendererConfig, SchemaLinkRendererProps, SchemaRenderer, SchemaRendererProps } from "./react/renderer-registry.js";
+import { ReactLinkDefaultToolbarItemKey, ReactLinkDefaultToolbarItems, ReactLinkPluginProps } from "./react/type.js";
 import { ReactLinkPlugin } from "./react/ReactLinkPlugin.js";
 import "./react/index.js";
-import { ILinkService } from "./service/i-link-service.js";
-export { ILinkService, INSERT_LINK_COMMAND, LinkPlugin, LinkPluginOptions, ReactLinkPlugin, type ReactLinkPluginProps };
+export { ILinkService, INSERT_LINK_COMMAND, type LinkCardRenderer, type LinkCardRendererProps, type LinkEmbedRule, type LinkIframeRenderer, type LinkIframeRendererProps, type LinkLabels, LinkPlugin, LinkPluginOptions, type LinkToolbarAction, type LinkToolbarItem, type LinkToolbarItemIcon, type LinkToolbarRenderContext, type ParsedSchemaUrl, type ReactLinkDefaultToolbarItemKey, type ReactLinkDefaultToolbarItems, ReactLinkPlugin, type ReactLinkPluginProps, type ReactSchemaRule, type SchemaLinkRenderer, type SchemaLinkRendererConfig, type SchemaLinkRendererProps, type SchemaRenderer, type SchemaRendererProps, type SchemaRule, getNodeTitle, getNodeUrl, normalizeProtocol, normalizeSchemaLinkNode };

package/es/plugins/link/node/LinkBlockCardNode.d.ts

@@ -0,0 +1,16 @@
+import { LinkCardNode, SerializedLinkCardNode } from "./LinkCardNode.js";
+import { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey } from "lexical";
+//#region src/plugins/link/node/LinkBlockCardNode.d.ts
+declare class LinkBlockCardNode extends LinkCardNode {
+  static getType(): string;
+  static clone(node: LinkBlockCardNode): LinkBlockCardNode;
+  static importJSON(serializedNode: SerializedLinkCardNode): LinkBlockCardNode;
+  static importDOM(): DOMConversionMap | null;
+  constructor(url: string, title?: string, icon?: string, description?: string, openTarget?: null | string, key?: NodeKey);
+  createDOM(config: EditorConfig, editor: LexicalEditor): HTMLElement;
+  exportDOM(): DOMExportOutput;
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedLinkCardNode>): this;
+  isInline(): false;
+}
+//#endregion
+export { LinkBlockCardNode };

package/es/plugins/link/node/LinkBlockCardNode.js

@@ -0,0 +1,66 @@
+import { LinkCardNode } from "./LinkCardNode.js";
+import { $applyNodeReplacement } from "lexical";
+//#region src/plugins/link/node/LinkBlockCardNode.ts
+var LinkBlockCardNode = class LinkBlockCardNode extends LinkCardNode {
+	static getType() {
+		return "link-block-card";
+	}
+	static clone(node) {
+		return new LinkBlockCardNode(node.__url, node.__title, node.__icon, node.__description, node.__openTarget, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createLinkBlockCardNode({
+			description: serializedNode.description,
+			icon: serializedNode.icon,
+			openTarget: serializedNode.openTarget,
+			title: serializedNode.title,
+			url: serializedNode.url
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { a: (node) => {
+			if (node instanceof HTMLAnchorElement && node.dataset.linkCard === "true" && node.dataset.linkCardLayout === "block") return {
+				conversion: $convertLinkBlockCardElement,
+				priority: 3
+			};
+			return null;
+		} };
+	}
+	constructor(url, title, icon, description, openTarget, key) {
+		super(url, title, icon, description, openTarget, key);
+	}
+	createDOM(config, editor) {
+		const element = super.createDOM(config, editor);
+		element.dataset.linkCardLayout = "block";
+		return element;
+	}
+	exportDOM() {
+		const output = super.exportDOM();
+		if (output.element instanceof HTMLElement) output.element.dataset.linkCardLayout = "block";
+		return output;
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode);
+	}
+	isInline() {
+		return false;
+	}
+};
+function $createLinkBlockCardNode(payload) {
+	return $applyNodeReplacement(new LinkBlockCardNode(payload.url, payload.title, payload.icon, payload.description, payload.openTarget));
+}
+function $convertLinkBlockCardElement(domNode) {
+	const element = domNode;
+	return { node: $createLinkBlockCardNode({
+		description: element.dataset.description,
+		icon: element.dataset.icon,
+		openTarget: element.getAttribute("target"),
+		title: element.textContent || element.href,
+		url: element.getAttribute("href") || ""
+	}) };
+}
+function $isLinkBlockCardNode(node) {
+	return node instanceof LinkBlockCardNode || node?.getType?.() === LinkBlockCardNode.getType();
+}
+//#endregion
+export { $createLinkBlockCardNode, $isLinkBlockCardNode, LinkBlockCardNode };

package/es/plugins/link/node/LinkCardNode.d.ts

@@ -0,0 +1,42 @@
+import { DOMConversionMap, DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey, SerializedLexicalNode, Spread } from "lexical";
+//#region src/plugins/link/node/LinkCardNode.d.ts
+type SerializedLinkCardNode = Spread<{
+  description: string;
+  icon: string;
+  openTarget: null | string;
+  title: string;
+  url: string;
+}, SerializedLexicalNode>;
+declare class LinkCardNode extends DecoratorNode<unknown> {
+  __url: string;
+  __title: string;
+  __icon: string;
+  __description: string;
+  __openTarget: null | string;
+  static getType(): string;
+  static clone(node: LinkCardNode): LinkCardNode;
+  static importJSON(serializedNode: SerializedLinkCardNode): LinkCardNode;
+  static importDOM(): DOMConversionMap | null;
+  constructor(url: string, title?: string, icon?: string, description?: string, openTarget?: null | string, key?: NodeKey);
+  createDOM(config: EditorConfig, editor: LexicalEditor): HTMLElement;
+  updateDOM(): false;
+  isInline(): boolean;
+  isKeyboardSelectable(): true;
+  exportDOM(): DOMExportOutput;
+  exportJSON(): SerializedLinkCardNode;
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedLinkCardNode>): this;
+  getTextContent(): string;
+  getURL(): string;
+  setURL(url: string): this;
+  getTitle(): string;
+  setTitle(title?: string): this;
+  getIcon(): string;
+  setIcon(icon?: string): this;
+  getDescription(): string;
+  setDescription(description?: string): this;
+  getOpenTarget(): null | string;
+  setOpenTarget(openTarget?: null | string): this;
+  decorate(editor: LexicalEditor): unknown;
+}
+//#endregion
+export { LinkCardNode, SerializedLinkCardNode };