@lobehub/editor 4.24.1 → 4.25.1

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

@@ -0,0 +1,149 @@
+import { getKernelFromEditor, init_utils } from "../../../editor-kernel/utils.js";
+import { HOVER_LINK_COMMAND, HOVER_OUT_LINK_COMMAND } from "./LinkNode.js";
+import { $applyNodeReplacement, DecoratorNode } from "lexical";
+import { addClassNamesToElement } from "@lexical/utils";
+//#region src/plugins/link/node/SchemaNode.ts
+init_utils();
+var SchemaNode = class SchemaNode extends DecoratorNode {
+	static getType() {
+		return "schema-link";
+	}
+	static clone(node) {
+		return new SchemaNode(node.__url, node.__schemaType, node.__payload, node.__title, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createSchemaNode({
+			payload: serializedNode.payload,
+			schemaType: serializedNode.schemaType,
+			title: serializedNode.title,
+			url: serializedNode.url
+		}).updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { a: (node) => {
+			if (node instanceof HTMLAnchorElement && node.dataset.schemaLink === "true") return {
+				conversion: $convertSchemaElement,
+				priority: 2
+			};
+			return null;
+		} };
+	}
+	constructor(url, schemaType, payload, title, key) {
+		super(key);
+		this.__url = url;
+		this.__schemaType = schemaType || "";
+		this.__payload = payload;
+		this.__title = title || url;
+	}
+	createDOM(config, editor) {
+		const element = document.createElement("div");
+		element.dataset.schemaLink = "true";
+		addClassNamesToElement(element, config.theme.schemaLink);
+		element.addEventListener("mouseenter", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.add("hover");
+				editor.dispatchCommand(HOVER_LINK_COMMAND, {
+					event,
+					node: this
+				});
+			}
+		});
+		element.addEventListener("mouseleave", (event) => {
+			if (event.target instanceof HTMLElement) {
+				event.target.classList.remove("hover");
+				editor.dispatchCommand(HOVER_OUT_LINK_COMMAND, { event });
+			}
+		});
+		return element;
+	}
+	updateDOM() {
+		return false;
+	}
+	exportDOM() {
+		const element = document.createElement("a");
+		element.dataset.schemaLink = "true";
+		element.dataset.schemaType = this.getSchemaType();
+		element.dataset.payload = JSON.stringify(this.getPayload() ?? null);
+		element.href = this.getURL();
+		element.textContent = this.getTitle();
+		return { element };
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			payload: this.getPayload(),
+			schemaType: this.getSchemaType(),
+			title: this.getTitle(),
+			url: this.getURL()
+		};
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setURL(serializedNode.url).setSchemaType(serializedNode.schemaType).setPayload(serializedNode.payload).setTitle(serializedNode.title);
+	}
+	getTextContent() {
+		return this.getTitle();
+	}
+	getURL() {
+		return this.getLatest().__url;
+	}
+	setURL(url) {
+		const writable = this.getWritable();
+		writable.__url = url;
+		return writable;
+	}
+	getSchemaType() {
+		return this.getLatest().__schemaType;
+	}
+	setSchemaType(schemaType) {
+		const writable = this.getWritable();
+		writable.__schemaType = schemaType || "";
+		return writable;
+	}
+	getPayload() {
+		return this.getLatest().__payload;
+	}
+	setPayload(payload) {
+		const writable = this.getWritable();
+		writable.__payload = payload;
+		return writable;
+	}
+	getTitle() {
+		return this.getLatest().__title || this.getURL();
+	}
+	setTitle(title) {
+		const writable = this.getWritable();
+		writable.__title = title || this.getURL();
+		return writable;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator(SchemaNode.getType());
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return decorator.render(this, editor);
+	}
+};
+function $createSchemaNode(payload) {
+	return $applyNodeReplacement(new SchemaNode(payload.url, payload.schemaType, payload.payload, payload.title));
+}
+function $convertSchemaElement(domNode) {
+	const element = domNode;
+	return { node: $createSchemaNode({
+		payload: parsePayload(element.dataset.payload),
+		schemaType: element.dataset.schemaType,
+		title: element.textContent || element.href,
+		url: element.getAttribute("href") || ""
+	}) };
+}
+function parsePayload(value) {
+	if (!value) return void 0;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function $isSchemaNode(node) {
+	return node instanceof SchemaNode || node?.getType?.() === SchemaNode.getType();
+}
+//#endregion
+export { $createSchemaNode, $isSchemaNode, SchemaNode };

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

@@ -0,0 +1,7 @@
+import { LinkNode } from "../node/LinkNode.js";
+import { LinkService } from "../service/i-link-service.js";
+import { LexicalEditor } from "lexical";
+//#region src/plugins/link/normalization/index.d.ts
+declare function normalizeSchemaLinkNode(node: LinkNode, editor: LexicalEditor, linkService: LinkService): boolean;
+//#endregion
+export { normalizeSchemaLinkNode };

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

@@ -0,0 +1,38 @@
+import { $createSchemaNode } from "../node/SchemaNode.js";
+//#region src/plugins/link/normalization/index.ts
+function normalizeSchemaLinkNode(node, editor, linkService) {
+	const url = node.getURL();
+	const title = node.getTitle() || node.getTextContent() || url;
+	const schema = linkService.parseSchemaUrl(url);
+	const rule = linkService.getSchemaRule(url, {
+		editor,
+		schema,
+		text: node.getTextContent(),
+		title
+	});
+	if (!rule) return false;
+	const parsed = rule.parse?.(url, schema);
+	const payload = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? normalizeSchemaPayload(parsed) : { payload: parsed };
+	if (linkService.hasSchemaLinkRenderer(url)) payload.payload = {
+		...payload.payload && typeof payload.payload === "object" ? payload.payload : {},
+		__legacyLink: {
+			rel: node.getRel(),
+			target: node.getTarget(),
+			text: node.getTextContent(),
+			title: node.getTitle()
+		}
+	};
+	node.replace($createSchemaNode({
+		payload: payload.payload,
+		schemaType: payload.schemaType || rule.id,
+		title: payload.title || title,
+		url: payload.url || url
+	}));
+	return true;
+}
+function normalizeSchemaPayload(payload) {
+	if ("payload" in payload || "schemaType" in payload || "title" in payload || "url" in payload) return payload;
+	return { payload };
+}
+//#endregion
+export { normalizeSchemaLinkNode };

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

@@ -1,16 +1,41 @@
 import { IEditorPluginConstructor } from "../../../types/kernel.js";
 import "../../../types/index.js";
+import { LinkCardNode } from "../node/LinkCardNode.js";
+import { LinkIframeNode } from "../node/LinkIframeNode.js";
 import { LinkAttributes } from "../node/LinkNode.js";
+import { SchemaNode } from "../node/SchemaNode.js";
+import { LinkEmbedRule, LinkLabels, LinkToolbarAction, SchemaLinkRendererConfig, SchemaRule } from "../service/i-link-service.js";
+import { normalizeSchemaLinkNode } from "../normalization/index.js";
+import { LexicalEditor } from "lexical";
 //#region src/plugins/link/plugin/index.d.ts
 interface LinkPluginOptions {
+  allowedProtocols?: string[];
+  /** Registration-time option. Recreate LinkPlugin to apply changes. */
   attributes?: LinkAttributes;
+  decoratorCard?: (node: LinkCardNode, editor: LexicalEditor) => any;
+  decoratorIframe?: (node: LinkIframeNode, editor: LexicalEditor) => any;
+  decoratorSchema?: (node: SchemaNode, editor: LexicalEditor) => any;
+  /** Registration-time option. Recreate LinkPlugin to apply changes. */
   enableHotkey?: boolean;
+  labels?: Partial<LinkLabels>;
+  linkEmbedRules?: LinkEmbedRule[];
+  /** Registration-time option. Recreate LinkPlugin to apply changes. */
   linkRegex?: RegExp;
+  /** Registration-time normalization strategy. Defaults to true for legacy compatibility. */
+  normalizeSchemaLinks?: boolean;
+  schemaLinkRenderers?: SchemaLinkRendererConfig[];
+  schemaRules?: SchemaRule[];
+  /** Registration-time option. Recreate LinkPlugin to apply changes. */
   theme?: {
     link?: string;
+    linkCard?: string;
+    linkIframe?: string;
+    schemaLink?: string;
   };
+  toolbarActions?: LinkToolbarAction[];
+  /** Registration-time option. Recreate LinkPlugin to apply changes. */
   validateUrl?: (url: string) => boolean;
 }
 declare const LinkPlugin: IEditorPluginConstructor<LinkPluginOptions>;
 //#endregion
-export { LinkPlugin, LinkPluginOptions };
+export { LinkPlugin, LinkPluginOptions, normalizeSchemaLinkNode };

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

@@ -2,9 +2,14 @@ import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js
 import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
 import { ILitexmlService } from "../../litexml/service/litexml-service.js";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut.js";
+import { ILinkService, LinkService } from "../service/i-link-service.js";
 import { $createLinkNode, $isLinkNode, AutoLinkNode, LinkNode } from "../node/LinkNode.js";
 import { INSERT_LINK_COMMAND, registerLinkCommand } from "../command/index.js";
-import { ILinkService, LinkService } from "../service/i-link-service.js";
+import { $isLinkCardNode, LinkCardNode } from "../node/LinkCardNode.js";
+import { $isLinkBlockCardNode, LinkBlockCardNode } from "../node/LinkBlockCardNode.js";
+import { $isLinkIframeNode, LinkIframeNode } from "../node/LinkIframeNode.js";
+import { $isSchemaNode, SchemaNode } from "../node/SchemaNode.js";
+import { normalizeSchemaLinkNode } from "../normalization/index.js";
 import { registerLinkCommands } from "./registry.js";
 import { $createTextNode, COMMAND_PRIORITY_NORMAL, PASTE_COMMAND } from "lexical";
 //#region src/plugins/link/plugin/index.ts
@@ -18,10 +23,22 @@ const LinkPlugin = class extends KernelPlugin {
 		super();
 		this.kernel = kernel;
 		this.config = config;
-		this.linkRegex = /^https?:\/\/\S+$/;
+		this.linkRegex = /^[a-z][\d+.a-z-]*:\/\/\S+$/i;
 		this.service = new LinkService();
-		kernel.registerNodes([LinkNode, AutoLinkNode]);
+		kernel.registerNodes([
+			LinkNode,
+			AutoLinkNode,
+			LinkCardNode,
+			LinkBlockCardNode,
+			LinkIframeNode,
+			SchemaNode
+		]);
+		this.service.updateConfig(config);
 		kernel.registerService(ILinkService, this.service);
+		this.registerDecorator(kernel, LinkCardNode.getType(), (node, editor) => config?.decoratorCard ? config.decoratorCard(node, editor) : null);
+		this.registerDecorator(kernel, LinkBlockCardNode.getType(), (node, editor) => config?.decoratorCard ? config.decoratorCard(node, editor) : null);
+		this.registerDecorator(kernel, LinkIframeNode.getType(), (node, editor) => config?.decoratorIframe ? config.decoratorIframe(node, editor) : null);
+		this.registerDecorator(kernel, SchemaNode.getType(), (node, editor) => config?.decoratorSchema ? config.decoratorSchema(node, editor) : null);
 		if (config?.theme) kernel.registerThemes(config.theme);
 		if (config?.linkRegex) this.linkRegex = config.linkRegex;
 	}
@@ -45,6 +62,9 @@ const LinkPlugin = class extends KernelPlugin {
 			}
 			return false;
 		}, COMMAND_PRIORITY_NORMAL));
+		if (this.config?.normalizeSchemaLinks !== false) this.register(editor.registerNodeTransform(LinkNode, (node) => {
+			normalizeSchemaLinkNode(node, editor, this.service);
+		}));
 		this.registerMarkdown();
 		this.registerLiteXml();
 	}
@@ -69,6 +89,74 @@ const LinkPlugin = class extends KernelPlugin {
 				version: 1
 			})];
 		});
+		litexmlService.registerXMLWriter(LinkCardNode.getType(), (node, ctx) => {
+			if (!$isLinkCardNode(node)) return false;
+			return ctx.createXmlNode("link-card", {
+				description: node.getDescription(),
+				href: node.getURL(),
+				icon: node.getIcon(),
+				openTarget: node.getOpenTarget() || "_blank",
+				title: node.getTitle()
+			});
+		});
+		litexmlService.registerXMLWriter(LinkBlockCardNode.getType(), (node, ctx) => {
+			if (!$isLinkBlockCardNode(node)) return false;
+			return ctx.createXmlNode("link-card", {
+				description: node.getDescription(),
+				href: node.getURL(),
+				icon: node.getIcon(),
+				layout: "block",
+				openTarget: node.getOpenTarget() || "_blank",
+				title: node.getTitle()
+			});
+		});
+		litexmlService.registerXMLReader("link-card", (xmlNode) => {
+			return [INodeHelper.createTypeNode(xmlNode.getAttribute("layout") === "block" ? LinkBlockCardNode.getType() : LinkCardNode.getType(), {
+				description: xmlNode.getAttribute("description") || "",
+				icon: xmlNode.getAttribute("icon") || "",
+				openTarget: xmlNode.getAttribute("openTarget") || "_blank",
+				title: xmlNode.getAttribute("title") || xmlNode.getAttribute("href") || "",
+				type: xmlNode.getAttribute("layout") === "block" ? LinkBlockCardNode.getType() : LinkCardNode.getType(),
+				url: xmlNode.getAttribute("href") || "",
+				version: 1
+			})];
+		});
+		litexmlService.registerXMLWriter(LinkIframeNode.getType(), (node, ctx) => {
+			if (!$isLinkIframeNode(node)) return false;
+			return ctx.createXmlNode("link-iframe", {
+				href: node.getURL(),
+				src: node.getSrc(),
+				title: node.getTitle()
+			});
+		});
+		litexmlService.registerXMLReader("link-iframe", (xmlNode) => {
+			return [INodeHelper.createTypeNode(LinkIframeNode.getType(), {
+				src: xmlNode.getAttribute("src") || xmlNode.getAttribute("href") || "",
+				title: xmlNode.getAttribute("title") || xmlNode.getAttribute("href") || "",
+				type: LinkIframeNode.getType(),
+				url: xmlNode.getAttribute("href") || "",
+				version: 1
+			})];
+		});
+		litexmlService.registerXMLWriter(SchemaNode.getType(), (node, ctx) => {
+			if (!$isSchemaNode(node)) return false;
+			return ctx.createXmlNode("schema-link", {
+				href: node.getURL(),
+				payload: JSON.stringify(node.getPayload() ?? null),
+				schemaType: node.getSchemaType(),
+				title: node.getTitle()
+			});
+		});
+		litexmlService.registerXMLReader("schema-link", (xmlNode) => {
+			return [INodeHelper.createTypeNode(SchemaNode.getType(), {
+				payload: parseJsonAttribute(xmlNode.getAttribute("payload")),
+				schemaType: xmlNode.getAttribute("schemaType") || "",
+				title: xmlNode.getAttribute("title") || xmlNode.getAttribute("href") || "",
+				type: SchemaNode.getType(),
+				url: xmlNode.getAttribute("href") || "",
+				version: 1
+			})];
+		});
 	}
 	registerMarkdown() {
 		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownShortCut({
@@ -88,6 +176,30 @@ const LinkPlugin = class extends KernelPlugin {
 		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(LinkNode.getType(), (ctx, node) => {
 			if ($isLinkNode(node)) ctx.wrap("[", `](${node.getURL()})`);
 		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(LinkCardNode.getType(), (ctx, node) => {
+			if ($isLinkCardNode(node)) {
+				ctx.appendLine(`[${node.getTitle()}](${node.getURL()})\n`);
+				return true;
+			}
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(LinkBlockCardNode.getType(), (ctx, node) => {
+			if ($isLinkBlockCardNode(node)) {
+				ctx.appendLine(`[${node.getTitle()}](${node.getURL()})\n`);
+				return true;
+			}
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(LinkIframeNode.getType(), (ctx, node) => {
+			if ($isLinkIframeNode(node)) {
+				ctx.appendLine(`[${node.getTitle()}](${node.getURL()})\n`);
+				return true;
+			}
+		});
+		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownWriter(SchemaNode.getType(), (ctx, node) => {
+			if ($isSchemaNode(node)) {
+				ctx.appendLine(`[${node.getTitle()}](${node.getURL()})\n`);
+				return true;
+			}
+		});
 		this.kernel.requireService(IMarkdownShortCutService)?.registerMarkdownReader("link", (node, children) => {
 			return [INodeHelper.createElementNode("link", {
 				children,
@@ -102,5 +214,13 @@ const LinkPlugin = class extends KernelPlugin {
 		});
 	}
 };
+function parseJsonAttribute(value) {
+	if (!value) return void 0;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
 //#endregion
-export { LinkPlugin };
+export { LinkPlugin, normalizeSchemaLinkNode };

package/es/plugins/link/react/ReactLinkPlugin.js

@@ -2,49 +2,207 @@
 import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context.js";
 import { useLexicalEditor } from "../../../editor-kernel/react/useLexicalEditor.js";
 import { MarkdownPlugin } from "../../markdown/plugin/index.js";
+import { useTranslation } from "../../../editor-kernel/react/useTranslation.js";
 import { ILinkService } from "../service/i-link-service.js";
+import { UNLINK_LINK_COMMAND } from "../command/index.js";
 import { LinkPlugin } from "../plugin/index.js";
+import { useEditable } from "../../../editor-kernel/react/useEditable.js";
 import PortalAnchor from "../../../editor-kernel/react/PortalAnchor.js";
+import LinkCard from "./components/LinkCard.js";
 import { styles } from "./style.js";
-import LinkEdit from "./components/LinkEdit.js";
+import LinkEdit, { EDIT_LINK_COMMAND } from "./components/LinkEdit.js";
+import LinkIframe from "./components/LinkIframe.js";
 import LinkToolbar from "./components/LinkToolbar.js";
-import { useLayoutEffect, useState } from "react";
+import SchemaLink from "./components/SchemaLink.js";
+import { LinkReactRendererRegistry, splitReactSchemaRules } from "./renderer-registry.js";
+import { useLayoutEffect, useMemo, useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
+import { message } from "antd";
 //#region src/plugins/link/react/ReactLinkPlugin.tsx
-const ReactLinkPlugin = ({ theme, enableHotkey = true, validateUrl, attributes }) => {
-	const [enableToolbar, setEnableToolbar] = useState(false);
+async function copyTextToClipboard(text) {
+	try {
+		await navigator.clipboard.writeText(text);
+	} catch {
+		const textarea = document.createElement("textarea");
+		textarea.value = text;
+		document.body.append(textarea);
+		textarea.select();
+		document.execCommand("copy");
+		textarea.remove();
+	}
+}
+function isDefaultToolbarItemEnabled(defaultToolbarItems, key) {
+	if (defaultToolbarItems === false) return false;
+	if (defaultToolbarItems === true || defaultToolbarItems === void 0) return true;
+	return defaultToolbarItems[key] !== false;
+}
+const ReactLinkPlugin = ({ allowedProtocols, theme, enableHotkey = true, validateUrl, attributes, defaultToolbarItems, labels, linkEmbedRules, normalizeSchemaLinks, renderLinkCard, renderLinkIframe, renderSchema, schemaLinkRenderers, schemaRules, toolbarActions }) => {
+	const [enableToolbar, setEnableToolbar] = useState(true);
+	const [linkService, setLinkService] = useState(null);
 	const [editor] = useLexicalComposerContext();
+	const { editable } = useEditable();
+	const t = useTranslation();
+	const registeredRef = useRef(false);
+	const rendererRegistryRef = useRef(new LinkReactRendererRegistry());
+	const splitSchemaRules = useMemo(() => splitReactSchemaRules(schemaRules), [schemaRules]);
 	useLayoutEffect(() => {
+		if (registeredRef.current) return;
+		registeredRef.current = true;
 		editor.registerPlugin(MarkdownPlugin);
 		editor.registerPlugin(LinkPlugin, {
+			allowedProtocols,
 			attributes,
+			decoratorCard: (node, editor) => /* @__PURE__ */ jsx(LinkCard, {
+				description: node.getDescription(),
+				editor,
+				icon: node.getIcon(),
+				node,
+				openTarget: node.getOpenTarget(),
+				rendererRegistry: rendererRegistryRef.current,
+				title: node.getTitle(),
+				url: node.getURL()
+			}),
+			decoratorIframe: (node, editor) => /* @__PURE__ */ jsx(LinkIframe, {
+				editor,
+				node,
+				rendererRegistry: rendererRegistryRef.current,
+				src: node.getSrc(),
+				title: node.getTitle(),
+				url: node.getURL()
+			}),
+			decoratorSchema: (node, editor) => /* @__PURE__ */ jsx(SchemaLink, {
+				editor,
+				node,
+				rendererRegistry: rendererRegistryRef.current
+			}),
 			enableHotkey,
+			labels,
+			linkEmbedRules,
+			normalizeSchemaLinks,
+			schemaLinkRenderers: getSchemaLinkRendererProtocols(schemaLinkRenderers),
+			schemaRules: splitSchemaRules.coreRules,
 			theme: theme || styles,
+			toolbarActions,
 			validateUrl
 		});
 	}, [
+		allowedProtocols,
 		attributes,
 		enableHotkey,
+		labels,
+		linkEmbedRules,
+		normalizeSchemaLinks,
+		schemaLinkRenderers,
+		schemaRules,
 		styles,
 		theme,
+		toolbarActions,
 		validateUrl
 	]);
+	useLayoutEffect(() => {
+		rendererRegistryRef.current.update({
+			renderLinkCard,
+			renderLinkIframe,
+			renderSchema,
+			schemaLinkRenderers,
+			schemaRenderers: splitSchemaRules.schemaRenderers
+		});
+	}, [
+		renderLinkCard,
+		renderLinkIframe,
+		renderSchema,
+		schemaLinkRenderers,
+		splitSchemaRules.schemaRenderers
+	]);
+	useLayoutEffect(() => {
+		if (!registeredRef.current) return;
+		editor.requireService(ILinkService)?.updateConfig({
+			allowedProtocols,
+			labels,
+			linkEmbedRules,
+			schemaLinkRenderers: getSchemaLinkRendererProtocols(schemaLinkRenderers),
+			schemaRules: splitSchemaRules.coreRules,
+			toolbarActions
+		});
+	}, [
+		allowedProtocols,
+		editor,
+		labels,
+		linkEmbedRules,
+		schemaLinkRenderers,
+		splitSchemaRules.coreRules,
+		toolbarActions
+	]);
 	useLexicalEditor(() => {
 		const linkService = editor.requireService(ILinkService);
+		setLinkService(linkService);
 		setEnableToolbar(linkService.enableLinkToolbar);
 		const handleChange = () => {
 			setEnableToolbar(linkService.enableLinkToolbar);
 		};
 		linkService.on("linkToolbarChange", handleChange);
+		const unregisterItems = [];
+		const registerDefaultToolbarItem = (key, item) => {
+			if (!isDefaultToolbarItemEnabled(defaultToolbarItems, key)) return;
+			unregisterItems.push(linkService.registerToolbarItem(item));
+		};
+		registerDefaultToolbarItem("open", {
+			icon: "open",
+			key: "open",
+			label: "link.open",
+			onClick: ({ editor, linkNode }) => {
+				const linkUrl = editor.getEditorState().read(() => linkNode.getURL());
+				window.open(linkUrl, "_blank");
+			},
+			order: 10
+		});
+		registerDefaultToolbarItem("edit", {
+			icon: "edit",
+			key: "edit",
+			label: "link.edit",
+			onClick: ({ close, editor, linkDom, linkNode }) => {
+				close();
+				editor.dispatchCommand(EDIT_LINK_COMMAND, {
+					linkNode,
+					linkNodeDOM: linkDom
+				});
+			},
+			order: 20
+		});
+		registerDefaultToolbarItem("copy", {
+			icon: "copy",
+			key: "copy",
+			label: "link.copy",
+			onClick: async ({ editor, linkNode }) => {
+				await copyTextToClipboard(editor.getEditorState().read(() => linkNode.getURL()));
+				message.success(t("link.copySuccess"));
+			},
+			order: 30
+		});
+		registerDefaultToolbarItem("unlink", {
+			icon: "unlink",
+			key: "unlink",
+			label: "link.unlink",
+			onClick: ({ close, editor, linkNode }) => {
+				editor.dispatchCommand(UNLINK_LINK_COMMAND, { key: linkNode.getKey() });
+				close();
+			},
+			order: 40
+		});
 		return () => {
 			linkService.off("linkToolbarChange", handleChange);
+			unregisterItems.forEach((unregister) => unregister());
 		};
-	}, []);
+	}, [defaultToolbarItems, t]);
 	return /* @__PURE__ */ jsxs(PortalAnchor, { children: [/* @__PURE__ */ jsx(LinkToolbar, {
 		editor: editor.getLexicalEditor(),
-		enable: enableToolbar
-	}), /* @__PURE__ */ jsx(LinkEdit, { editor: editor.getLexicalEditor() })] });
+		enable: enableToolbar && editable,
+		linkService
+	}), editable && /* @__PURE__ */ jsx(LinkEdit, { editor: editor.getLexicalEditor() })] });
 };
 ReactLinkPlugin.displayName = "ReactLinkPlugin";
+function getSchemaLinkRendererProtocols(renderers) {
+	return renderers?.map(({ protocol }) => ({ protocol }));
+}
 //#endregion
 export { ReactLinkPlugin, ReactLinkPlugin as default };