feat: 链接支持打开本地文件

Author: LarryZhu-dev

src/core/editor.ts

@@ -537,14 +537,13 @@ export class MilkupEditor implements IMilkupEditor {
         me.preventDefault();
         me.stopPropagation();
 
-        let href = this.getLinkHref(linkEl);
+        const href = this.getLinkHref(linkEl);
         if (href) {
-          // 补全协议前缀，避免被当作本地文件路径
-          if (!/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(href)) {
-            href = "https://" + href;
-          }
           const electronAPI = (window as any).electronAPI;
-          if (electronAPI?.openExternal) {
+          const currentFilePath = (window as any).__currentFilePath || null;
+          if (electronAPI?.openLink) {
+            electronAPI.openLink(href, currentFilePath);
+          } else if (electronAPI?.openExternal) {
             electronAPI.openExternal(href);
           } else {
             window.open(href, "_blank", "noopener,noreferrer");

src/core/plugins/link-tooltip.ts

@@ -27,7 +27,10 @@ function findLinkElement(target: HTMLElement, root: HTMLElement): HTMLAnchorElem
 /** 用默认浏览器打开链接 */
 function openLinkExternal(href: string) {
   const electronAPI = (window as any).electronAPI;
-  if (electronAPI?.openExternal) {
+  const currentFilePath = (window as any).__currentFilePath || null;
+  if (electronAPI?.openLink) {
+    electronAPI.openLink(href, currentFilePath);
+  } else if (electronAPI?.openExternal) {
     electronAPI.openExternal(href);
   } else {
     window.open(href, "_blank", "noopener,noreferrer");

src/main/ipcBridge.ts

@@ -6,6 +6,7 @@ import type { FileTraits } from "./fileFormat";
 import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import chokidar from "chokidar";
 import { Document, HeadingLevel, Packer, Paragraph, TextRun } from "docx";
 import { app, BrowserWindow, clipboard, dialog, ipcMain, shell } from "electron";
@@ -17,7 +18,7 @@ import {
   restoreFileTraits,
 } from "./fileFormat";
 import { createThemeEditorWindow } from "./index";
-import { normalizeMarkdownFilePath, readMarkdownFile } from "./markdownFile";
+import { isMarkdownFilePath, normalizeMarkdownFilePath, readMarkdownFile } from "./markdownFile";
 import {
   cancelDragFollow,
   clearWindowDragPreview,
@@ -77,6 +78,86 @@ function normalizeRelativeImageDirectory(inputPath: string): string {
     .trim();
 }
 
+function hasUriScheme(target: string): boolean {
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(target) && !/^[a-zA-Z]:[\\/]/.test(target);
+}
+
+function isExternalLink(target: string): boolean {
+  return target.startsWith("//") || (hasUriScheme(target) && !/^file:/i.test(target));
+}
+
+function isObviousLocalPath(target: string): boolean {
+  return (
+    /^[a-zA-Z]:[\\/]/.test(target) ||
+    /^\\\\[^\\]/.test(target) ||
+    /^[\\/]/.test(target) ||
+    /^\.\.?([\\/]|$)/.test(target)
+  );
+}
+
+function localPathExists(filePath: string): boolean {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+function isLikelyHostnameWithoutProtocol(target: string): boolean {
+  const candidate = target.trim().split(/[?#]/)[0];
+  if (!candidate || /[\s\\]/.test(candidate)) return false;
+  if (isObviousLocalPath(candidate) || isExternalLink(candidate)) return false;
+
+  const firstSegment = candidate.split("/")[0];
+  if (!firstSegment) return false;
+
+  if (/^localhost(?::\d+)?$/i.test(firstSegment)) return true;
+  if (/^\d{1,3}(?:\.\d{1,3}){3}(?::\d+)?$/.test(firstSegment)) return true;
+  if (/^\[[0-9a-fA-F:]+\](?::\d+)?$/.test(firstSegment)) return true;
+  if (/^[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+(?::\d+)?$/.test(firstSegment)) return true;
+
+  return false;
+}
+
+function resolveLocalLinkPath(target: string, currentFilePath?: string | null): string | null {
+  const trimmed = target.trim();
+  if (!trimmed || trimmed.startsWith("#")) return null;
+
+  if (/^file:/i.test(trimmed)) {
+    try {
+      return fileURLToPath(trimmed);
+    } catch {
+      return null;
+    }
+  }
+
+  if (isExternalLink(trimmed)) return null;
+
+  const cleanPath = trimmed.split(/[?#]/)[0];
+  if (!cleanPath) return null;
+
+  if (path.isAbsolute(cleanPath) || /^\\\\[^\\]/.test(cleanPath)) {
+    return cleanPath;
+  }
+
+  if (!currentFilePath) return null;
+  const resolvedPath = path.resolve(path.dirname(currentFilePath), cleanPath);
+  if (localPathExists(resolvedPath)) return resolvedPath;
+
+  if (isLikelyHostnameWithoutProtocol(trimmed)) return null;
+
+  return resolvedPath;
+}
+
+function normalizeExternalLink(target: string): string {
+  const trimmed = target.trim();
+  if (!trimmed) return trimmed;
+  if (isExternalLink(trimmed) || /^file:/i.test(trimmed)) {
+    return trimmed.startsWith("//") ? `https:${trimmed}` : trimmed;
+  }
+  return `https://${trimmed}`;
+}
+
 function getImageOutputExtension(fileName?: string, mimeType?: string): string {
   const fileExt = fileName ? path.extname(fileName) : "";
   if (fileExt) {
@@ -255,6 +336,39 @@ export function registerIpcOnHandlers() {
   ipcMain.on("shell:openExternal", (_event, url) => {
     shell.openExternal(url);
   });
+  ipcMain.handle("shell:openLink", async (event, href: string, currentFilePath?: string | null) => {
+    const localPath = resolveLocalLinkPath(href, currentFilePath);
+    if (localPath) {
+      if (isMarkdownFilePath(localPath)) {
+        const sourceWin = BrowserWindow.fromWebContents(event.sender);
+        const targetWin = findWindowWithFile(localPath, sourceWin?.id);
+        if (targetWin) {
+          targetWin.webContents.send("tab:activate-file", localPath);
+          targetWin.focus();
+          return;
+        }
+
+        const result = readMarkdownFile(localPath);
+        if (result && sourceWin && !sourceWin.isDestroyed()) {
+          sourceWin.webContents.send("open-file-at-launch", {
+            filePath: result.filePath,
+            content: result.content,
+            fileTraits: result.fileTraits,
+          });
+          sourceWin.focus();
+          return;
+        }
+      }
+
+      await shell.openPath(localPath);
+      return;
+    }
+
+    const externalUrl = normalizeExternalLink(href);
+    if (externalUrl) {
+      await shell.openExternal(externalUrl);
+    }
+  });
   ipcMain.on("change-save-status", (event, isSavedStatus) => {
     const targetWin = BrowserWindow.fromWebContents(event.sender);
     if (!targetWin) return;

src/preload.ts

@@ -38,6 +38,8 @@ contextBridge.exposeInMainWorld("electronAPI", {
     });
   },
   openExternal: (url: string) => ipcRenderer.send("shell:openExternal", url),
+  openLink: (href: string, currentFilePath?: string | null) =>
+    ipcRenderer.invoke("shell:openLink", href, currentFilePath),
   getFilePathInClipboard: () => ipcRenderer.invoke("clipboard:getFilePath"),
   writeTempImage: (
     file: Uint8Array,

src/renderer/global.d.ts

@@ -30,6 +30,7 @@ interface Window {
       cb: (payload: { filePath: string; content: string; fileTraits?: FileTraitsDTO }) => void
     ) => void;
     openExternal: (url: string) => Promise<void>;
+    openLink: (href: string, currentFilePath?: string | null) => Promise<void>;
     getFilePathInClipboard: () => Promise<string | null>;
     writeTempImage: (
       file: Uint8Array<ArrayBuffer>,