Files
Thing/src/modules/diff/DiffWindow.vue
T

1320 lines
48 KiB
Vue
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<script setup lang="ts">
/**
* 对比工具独立窗口根组件(`#diff-window`,单例窗口 + 多选项卡)。
*
* # 选项卡 = 一次「对比会话」
*
* 每个选项卡是一对目标:**一对文件**(双栏差异视图)或**一对目录**(左右两棵结构树)。
* 标题就是 `左 ↔ 右`(与 Beyond Compare 一致)。从目录树点开一个文件会**新开一个文件
* 选项卡**(带着「返回目录对比」入口),而不是把目录视图替换掉 —— 目录级定位与内容级
* 阅读是两个动作,来回切换不该丢任何一边。
*
* # 状态放哪
*
* 会话状态(两个文件、两侧内容、脏标记、统计、过滤、扫描结果)都挂在会话对象上,
* 而不是散落成一堆 `ref`。这样「切选项卡」天然就是「换当前会话」:
*
* - 文件会话的**内容存在会话对象里**(字符串是原始值,不会进 Proxy,不用怕几 MB 的
* 文本被包一层);
* - 扫描结果 `markRaw` 掉(几千条条目进响应式会逐条生成 Proxy,纯开销);
* - **切走前先 `snapshotEdits()`**:`TextMergeView` 只有一个实例,会话内容才是真相 ——
* 不先把 CM6 里的编辑取回来就会被下一份内容覆盖(切个选项卡丢一次改动)。
*
* # 其它
*
* - 主题跟随主应用;配色复用编辑器的 CM6 主题(见 `TextMergeView`)。
* - 拖入按**当前选项卡类型**分派:文件选项卡装文件,目录选项卡装该侧根目录。
* - 全局快捷键 `Alt+C`(默认,可在模块页改)由 Rust 注册,主窗口 `App.vue` 监听后调
* `openDiffWindow()` 唤出本窗口。
*/
import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { Effect, EffectState, getCurrentWindow } from '@tauri-apps/api/window'
import { getCurrentWebview } from '@tauri-apps/api/webview'
import { invoke } from '@tauri-apps/api/core'
import { open } from '@tauri-apps/plugin-dialog'
import type { UnlistenFn } from '@tauri-apps/api/event'
import {
ArrowLeftRight,
ChevronDown,
ChevronLeft,
ChevronUp,
ClipboardPaste,
Diff,
Eraser,
FilePlus2,
FileText,
FolderOpen,
FolderTree,
Minus,
Save,
Square,
X
} from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Toaster } from '@/components/ui/sonner'
import { Button } from '@/components/ui/button'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
import {
Dialog,
DialogContent,
DialogDescription,
DialogFooter,
DialogHeader,
DialogTitle
} from '@/components/ui/dialog'
import { STORAGE_KEYS } from '@/lib/constants'
import { applyStoredAccent } from '@/lib/theme'
import { createLogger } from '@/lib/logger'
import { diffClient } from './diffClient'
import TextMergeView from './components/TextMergeView.vue'
import DirDiffView from './components/DirDiffView.vue'
import type {
DiffFileDoc,
DiffSettings,
DiffSide,
DiffStats,
DirDiffEntry,
DirFilterId,
DirSessionState
} from './types'
const logger = createLogger('diff')
const win = getCurrentWindow()
/** 两侧的固定顺序(模板按它成对渲染,天然与 MergeView 的 50/50 分栏对齐)。 */
const SIDES: readonly DiffSide[] = ['a', 'b']
/** 一侧的文件状态。 */
interface SideState {
/** 是否已关联磁盘文件(false = 用户粘贴的文本 / 为空) */
loaded: boolean
path: string
name: string
encoding: string
eol: string
size: number
modified: number
large: boolean
readonly: boolean
binary: boolean
/** 有未保存改动 */
dirty: boolean
loading: boolean
}
function emptySide(): SideState {
return {
loaded: false,
path: '',
name: '',
encoding: '',
eol: '',
size: 0,
modified: 0,
large: false,
readonly: false,
binary: false,
dirty: false,
loading: false
}
}
/** 一次「文件对比」会话。 */
interface FileSession {
id: string
kind: 'files'
sides: Record<DiffSide, SideState>
/** 两侧当前文本(用户编辑后的内容) */
contentA: string
contentB: string
stats: DiffStats
/** 从哪个目录选项卡下钻来的(空串 = 不是下钻来的)——「返回目录对比」用 */
fromDirTabId: string
}
/** 一次「目录对比」会话。 */
interface DirSession extends DirSessionState {
id: string
kind: 'dirs'
}
type Session = FileSession | DirSession
// ===== 会话与选项卡 =====
const sessions = ref<Session[]>([])
const activeId = ref('')
/** 空占位:没有任何文件会话时,模板与辅助函数不必到处判空 */
const EMPTY_SIDES: Record<DiffSide, SideState> = { a: emptySide(), b: emptySide() }
const active = computed<Session | null>(
() => sessions.value.find(s => s.id === activeId.value) ?? null
)
const activeFile = computed<FileSession | null>(() => (active.value?.kind === 'files' ? active.value : null))
const activeDir = computed<DirSession | null>(() => (active.value?.kind === 'dirs' ? active.value : null))
/** 当前文件会话的两侧状态(无文件会话时给出空占位,避免模板崩溃) */
const fileSides = computed<Record<DiffSide, SideState>>(() => activeFile.value?.sides ?? EMPTY_SIDES)
/**
* 目录会话的 `v-model:session` 句柄。
*
* `DirDiffView` 只改会话的**字段**(不整体替换),因此 getter-only 就够了;
* 组件渲染由 `v-else-if="activeDir"` 保证此时一定存在目录会话。
*/
const dirModel = computed<DirSessionState>({
get: () => activeDir.value as DirSessionState,
set: () => undefined
})
const mergeRef = ref<InstanceType<typeof TextMergeView> | null>(null)
const dirRef = ref<InstanceType<typeof DirDiffView> | null>(null)
const isDark = ref(false)
const dragSide = ref<DiffSide | null>(null)
const settings = ref<DiffSettings | null>(null)
/** 待确认关闭的选项卡 id(有未保存改动时先问;空串 = 关整窗) */
const pendingClose = ref('')
const closeConfirmOpen = ref(false)
let unlistenDragDrop: UnlistenFn | null = null
let seq = 0
function nextId(prefix: string): string {
seq += 1
return `${prefix}-${seq}`
}
/** 目录名 / 文件名(路径末段)。 */
function baseName(path: string): string {
const trimmed = path.replace(/[\\/]+$/, '')
const cut = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'))
return cut >= 0 ? trimmed.slice(cut + 1) : trimmed
}
/** 选项卡标题:`左 ↔ 右`。 */
function sessionTitle(session: Session): string {
if (session.kind === 'dirs') {
const left = session.leftRoot ? baseName(session.leftRoot) : '(未选)'
const right = session.rightRoot ? baseName(session.rightRoot) : '(未选)'
return `${left} ↔ ${right}`
}
const left = session.sides.a.loaded ? session.sides.a.name : '(空)'
const right = session.sides.b.loaded ? session.sides.b.name : '(空)'
return `${left} ↔ ${right}`
}
function fileSessionHasDirty(session: Session): boolean {
return session.kind === 'files' && (session.sides.a.dirty || session.sides.b.dirty)
}
const anyDirty = computed(() => sessions.value.some(fileSessionHasDirty))
// ===== 会话创建 =====
function makeFileSession(fromDirTabId = ''): FileSession {
return {
id: nextId('f'),
kind: 'files',
sides: { a: emptySide(), b: emptySide() },
contentA: '',
contentB: '',
stats: { chunks: 0, addedLines: 0, removedLines: 0, linesA: 0, linesB: 0 },
fromDirTabId
}
}
function makeDirSession(init?: Partial<DirSessionState>): DirSession {
return {
id: nextId('d'),
kind: 'dirs',
leftRoot: '',
rightRoot: '',
report: null,
scanning: false,
filter: 'diff',
collapsed: new Set<string>(),
// 默认值来自模块设置(读不到时用后端默认:比对内容 / 跳过构建目录都为真)
skipBuild: settings.value?.skipBuildDirs ?? true,
compareContent: settings.value?.compareContent ?? true,
...init
}
}
/** 新建文件选项卡并激活。 */
async function newFileTab(options?: { fromDirTabId?: string }): Promise<FileSession> {
const session = makeFileSession(options?.fromDirTabId ?? '')
sessions.value.push(session)
await activateTab(session.id)
return session
}
/** 新建目录选项卡并激活(`init` 用于带初始根路径,例如 `?path=` 传进来一个目录)。 */
async function newDirTab(init?: Partial<DirSessionState>, autoCompare = false): Promise<DirSession> {
const session = makeDirSession(init)
sessions.value.push(session)
await activateTab(session.id)
if (autoCompare && session.leftRoot && session.rightRoot) dirRef.value?.compare()
return session
}
/** 切走前把 CM6 里的未保存编辑取回会话(否则下一份内容会把它覆盖掉)。 */
function snapshotEdits(): void {
const session = activeFile.value
const mv = mergeRef.value
if (!session || !mv) return
if (session.sides.a.dirty) session.contentA = mv.getText('a')
if (session.sides.b.dirty) session.contentB = mv.getText('b')
}
/**
* 恢复出来的目录会话**只有目标、没有结果**:进入它时补扫一次。
*
* 空目录选项卡(没有两侧根)不会命中;已经在扫或已有结果的也不会重复触发。
*/
function scanDirIfNeeded(): void {
const dir = activeDir.value
if (dir && dir.leftRoot && dir.rightRoot && !dir.report && !dir.scanning) {
void dirRef.value?.compare()
}
}
/**
* 激活某个选项卡。
*
* `TextMergeView` 只有一个实例(`v-if` 按会话类型挂载),因此切换时要:先把当前文件
* 会话的编辑快照回去 → 换 activeId → 等视图重新挂载 / 内容重算 → 灌入新会话的内容。
*/
async function activateTab(id: string): Promise<void> {
if (id === activeId.value) return
snapshotEdits()
activeId.value = id
await nextTick()
if (activeFile.value) applyContents()
scanDirIfNeeded()
syncWindowTitle()
}
/** 关闭选项卡(有未保存改动时先确认)。 */
function requestCloseTab(id: string): void {
const session = sessions.value.find(s => s.id === id)
if (!session) return
// 脏就一定要问:**不能**用「编辑器是否挂载」当判据 —— 非激活选项卡的编辑内容
// 已经快照在会话对象里,静默丢弃同样是丢改动。
if (fileSessionHasDirty(session)) {
pendingClose.value = id
closeConfirmOpen.value = true
return
}
removeTab(id)
}
function removeTab(id: string): void {
const index = sessions.value.findIndex(s => s.id === id)
if (index < 0) return
const wasActive = id === activeId.value
sessions.value.splice(index, 1)
// 关掉的是最后一个:补一个空会话,窗口永远至少有一个选项卡
if (!sessions.value.length) {
const session = makeFileSession()
sessions.value.push(session)
activeId.value = session.id
void nextTick(() => applyContents())
return
}
if (wasActive) {
const next = sessions.value[Math.min(index, sessions.value.length - 1)]
if (next) {
// 直接置 activeId(不经过 snapshotEdits:刚移除的那个会话已经不需要保全)
activeId.value = next.id
void nextTick(() => {
if (activeFile.value) applyContents()
syncWindowTitle()
})
}
}
}
/** 会话标题同步到窗口标题(任务栏 / 悬停能看到在比什么)。 */
function syncWindowTitle(): void {
const session = active.value
const title = session ? `对比 — ${sessionTitle(session)}` : '对比'
win.setTitle(title).catch(() => undefined)
}
// ===== 会话持久化(窗口重开即恢复) =====
//
// 会话(开了哪些对比、各自比的是什么、各自的选项)落 localStorage,而不是只留在内存里
// ——「关掉窗口再打开,刚才那几对目标还在」才符合对比工具的用法(与编辑器会话恢复同一
// 姿态)。对比窗口是**单例**(label 固定 `diff-window`),因此不需要编辑器那种「按窗口
// 分桶」,一个键就够。
//
// 只存**目标与选项**,不存扫描结果:结果重新扫一次就有(且可能已经过期)。恢复出来的
// 目录选项卡在首次切到它时补扫一次(见 `activateTab`)。
/** 会话存储键 */
const SESSION_KEY = 'thing_diff_session'
/** 会话格式版本(结构变了就递增,旧数据直接丢弃) */
const SESSION_VERSION = 1
interface StoredFileTab {
kind: 'files'
a: string
b: string
}
interface StoredDirTab {
kind: 'dirs'
left: string
right: string
filter: DirFilterId
skipBuild: boolean
compareContent: boolean
}
type StoredTab = StoredFileTab | StoredDirTab
interface DiffSession {
version: number
tabs: StoredTab[]
activeIndex: number
}
/** 一个会话要持久化的字段(同时用作「变了才写」的判定串)。 */
function tabShape(session: Session): string {
if (session.kind === 'dirs') {
return `d|${session.leftRoot}|${session.rightRoot}|${session.filter}|${session.skipBuild}|${session.compareContent}`
}
return `f|${session.sides.a.path}|${session.sides.b.path}`
}
function saveSession(): void {
try {
const tabs: StoredTab[] = sessions.value.map(session =>
session.kind === 'dirs'
? {
kind: 'dirs',
left: session.leftRoot,
right: session.rightRoot,
filter: session.filter,
skipBuild: session.skipBuild,
compareContent: session.compareContent
}
: { kind: 'files', a: session.sides.a.path, b: session.sides.b.path }
)
const data: DiffSession = {
version: SESSION_VERSION,
tabs,
activeIndex: sessions.value.findIndex(s => s.id === activeId.value)
}
localStorage.setItem(SESSION_KEY, JSON.stringify(data))
} catch {
/* 存储不可用不影响使用 */
}
}
function readSession(): DiffSession | null {
try {
const raw = localStorage.getItem(SESSION_KEY)
if (!raw) return null
const parsed = JSON.parse(raw) as DiffSession
if (parsed.version !== SESSION_VERSION || !Array.isArray(parsed.tabs)) return null
return parsed
} catch {
return null
}
}
/**
* 恢复上次的对比会话(返回是否真的恢复了内容)。
*
* 文件选项卡要重新读一次两侧(磁盘上的文件可能已被改动甚至删除)—— 读失败只记日志、
* 留该侧为空,不让一篇读不到的文件把整个恢复流程带崩。
*/
async function restoreSession(): Promise<boolean> {
const data = readSession()
if (!data?.tabs.length) return false
const restored: Session[] = []
for (const stored of data.tabs) {
if (stored.kind === 'dirs') {
if (!stored.left || !stored.right) continue
restored.push(
makeDirSession({
leftRoot: stored.left,
rightRoot: stored.right,
filter: stored.filter,
skipBuild: stored.skipBuild,
compareContent: stored.compareContent
})
)
continue
}
const session = makeFileSession()
restored.push(session)
for (const [side, path] of [
['a', stored.a],
['b', stored.b]
] as const) {
if (!path) continue
try {
applyDoc(session, side, await diffClient.readFile(path))
} catch (e) {
logger.warn(`恢复对比文件失败(${path}):${String(e)}`)
}
}
}
if (!restored.length) return false
sessions.value = restored
const index = Math.min(Math.max(0, data.activeIndex), restored.length - 1)
const pick = restored[index]
if (!pick) return false
// 直接置 activeId:此刻视图里还没有任何会话的内容,不需要 snapshotEdits
activeId.value = pick.id
await nextTick()
if (activeFile.value) applyContents()
// 恢复出来的目录会话没有结果,进入它时补扫(否则看到的是空树)
scanDirIfNeeded()
syncWindowTitle()
return true
}
/** 标签形态一变就落一次会话(防抖 300ms;窗口被 Alt+F4 关掉时也靠它保住会话)。 */
const sessionShape = computed(() => [activeId.value, ...sessions.value.map(tabShape)].join('\u0000'))
let sessionTimer: ReturnType<typeof setTimeout> | null = null
watch(sessionShape, () => {
if (sessionTimer) clearTimeout(sessionTimer)
sessionTimer = setTimeout(() => {
sessionTimer = null
saveSession()
}, 300)
})
// ===== 文件内容装载 =====
/** 把当前文件会话的内容灌进 MergeView(二进制 / 无文件会话时空转)。 */
function applyContents(): void {
const session = activeFile.value
if (!session || !showMerge.value) return
mergeRef.value?.setTexts(session.contentA, session.contentB)
}
/** 用读取结果刷新当前会话某一侧的状态。 */
function applyDoc(session: FileSession, side: DiffSide, doc: DiffFileDoc): void {
session.sides[side] = {
loaded: true,
path: doc.path,
name: doc.name,
encoding: doc.encoding,
eol: doc.eol,
size: doc.size,
modified: doc.modified,
large: doc.large,
readonly: doc.readonly,
binary: doc.binary,
dirty: false,
loading: false
}
if (side === 'a') session.contentA = doc.content
else session.contentB = doc.content
}
/** 把当前会话某一侧恢复成「无文件」的空白状态。 */
function resetSide(side: DiffSide): void {
const session = activeFile.value
if (!session) return
session.sides[side] = emptySide()
if (side === 'a') session.contentA = ''
else session.contentB = ''
}
const showMerge = computed(() => {
const session = activeFile.value
if (!session) return false
return !session.sides.a.binary && !session.sides.b.binary
})
/** 两侧都来自文件、都是文本、且编码不一致 —— 「看起来全是乱码差异」的常见根因。 */
const encodingMismatch = computed(() => {
const session = activeFile.value
if (!session) return false
const a = session.sides.a
const b = session.sides.b
return (
a.loaded && b.loaded && !!a.encoding && !!b.encoding && a.encoding !== b.encoding
)
})
/** 二进制模式下只比大小(刻意不读内容,所以不能说「内容相同」)。 */
const binarySameSize = computed(() => {
const session = activeFile.value
if (!session) return false
return session.sides.a.binary && session.sides.b.binary && session.sides.a.size === session.sides.b.size
})
function formatSize(bytes: number): string {
if (bytes < 1024) return `${bytes} B`
if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
}
// `showMerge` 由 false 变 true(例如换掉了一侧那个二进制文件、或切回一个文本会话)时
// merge view 才重新挂载,需要在挂载完成后重新灌入内容 —— 否则新挂载的视图是空的。
//
// 由真变假(视图即将卸载)**不在这里处理**:那条路径(载入二进制文件)的快照保全放在
// `loadPathInto` 里做 —— 在 watcher 里快照会在「切到另一个本就是二进制的会话」时把旧
// 视图的内容误写进新会话。
watch(showMerge, async shown => {
if (!shown) return
await nextTick()
applyContents()
})
// ===== 打开文件 =====
async function loadPathInto(side: DiffSide, path: string): Promise<void> {
const session = activeFile.value
if (!session) return
session.sides[side].loading = true
try {
const doc = await diffClient.readFile(path)
// 载入的若是二进制文件,差异视图马上会被卸载(`showMerge` 变 false,见下面的 watcher)。
// **卸载前先把 CM6 里的编辑快照回会话**:编辑期间视图里的内容才是真相,视图一销毁,
// 未保存的改动就在内存里没了(会话里那份还是上次切走时的旧快照)。
// 放在这里而不是 watcher 里,是因为只有这条路径会让**当前**会话的 showMerge 由真变假;
// 在 watcher 里快照会在「切到另一个本就是二进制的会话」时把旧视图内容误写进新会话。
if (doc.binary && showMerge.value) snapshotEdits()
applyDoc(session, side, doc)
if (showMerge.value) applyContents()
if (doc.readonly && !doc.binary) {
toast.warning(`「${doc.name}」是只读文件,改动无法写回`)
}
syncWindowTitle()
} catch (e) {
toast.error(`打开失败:${String(e)}`)
} finally {
session.sides[side].loading = false
}
}
/** 用系统文件对话框选择某一侧的文件。 */
async function openSide(side: DiffSide): Promise<void> {
try {
const selected = await open({ multiple: false, directory: false, title: '选择要对比的文件' })
if (typeof selected !== 'string') return
await loadPathInto(side, selected)
} catch (e) {
toast.error(`打开失败:${String(e)}`)
}
}
// ===== 保存(单侧写回) =====
/**
* 某一侧当前应当写回的内容(`null` = 取不到,不能保存)。
*
* - 视图在(`showMerge` 真):编辑期间 CM6 里的内容才是真相,必须从视图取;
* - 视图已卸载(另一侧是二进制):会话快照就是最新内容(卸载前已 `snapshotEdits`),
* 退回它才让「二进制模式下仍能保存文本侧」成立;
* - `showMerge` 真但视图还没挂载好:取不到真相 → 返回 `null`,绝不把旧值 / 空串写盘。
*/
function currentText(session: FileSession, side: DiffSide): string | null {
if (showMerge.value) return mergeRef.value ? mergeRef.value.getText(side) : null
return side === 'a' ? session.contentA : session.contentB
}
async function saveSide(side: DiffSide, silent = false): Promise<boolean> {
const session = activeFile.value
if (!session) return false
const state = session.sides[side]
if (!state.loaded) return false
// 不可写回的原因要**说出来**:原来是静默返回 false,用户点保存毫无反应,不知道为何
if (state.binary) {
toast.error(`「${state.name || '二进制文件'}」不支持写回`)
return false
}
if (state.readonly) {
toast.error(`「${state.name || '该文件'}」为只读,无法保存`)
return false
}
const text = currentText(session, side)
if (text === null) {
toast.error('对比视图尚未就绪,请稍后重试')
return false
}
try {
const doc = await diffClient.writeFile(state.path, text, state.encoding, state.eol)
session.sides[side] = { ...state, size: doc.size, modified: doc.modified, dirty: false }
if (side === 'a') session.contentA = doc.content
else session.contentB = doc.content
if (!silent) toast.success(`已保存 ${doc.name}`)
return true
} catch (e) {
toast.error(`保存失败:${String(e)}`)
return false
}
}
/** 保存当前文件会话里所有脏的一侧;返回「是否全部成功」(任一失败即 false)。 */
async function saveAllDirty(): Promise<boolean> {
const session = activeFile.value
if (!session) return true
const dirty = SIDES.filter(side => session.sides[side].dirty)
let ok = true
for (const side of dirty) {
if (!(await saveSide(side, dirty.length > 1))) ok = false
}
return ok
}
/** Ctrl+S / 「保存并关闭」入口:先确保文件会话处于激活状态再保存。返回是否全部成功。 */
async function saveAllDirtyEnsuringFiles(): Promise<boolean> {
if (!anyDirty.value) return true
// 激活的文件会话可能不是那个脏的(例如脏的是另一个选项卡)——逐个保存所有文件会话
const current = activeId.value
let ok = true
for (const session of [...sessions.value]) {
if (session.kind !== 'files' || !(session.sides.a.dirty || session.sides.b.dirty)) continue
if (activeId.value !== session.id) await activateTab(session.id)
if (!(await saveAllDirty())) ok = false
}
if (activeId.value !== current) await activateTab(current)
return ok
}
// ===== 工具栏动作 =====
function moveChunk(direction: 1 | -1): void {
mergeRef.value?.moveChunk(direction)
}
/** 交换左右:文件模式下两侧的文件关联**不跟着换**(换的是内容),因此交换后两侧都是脏的。 */
function swapSides(): void {
mergeRef.value?.swapSides()
}
/** 清空两侧(连同文件关联一起复位,避免「空内容仍绑定磁盘路径」导致误保存)。 */
function clearAll(): void {
resetSide('a')
resetSide('b')
mergeRef.value?.clearAll()
syncWindowTitle()
}
async function pasteInto(side: DiffSide): Promise<void> {
const ok = await mergeRef.value?.pasteInto(side)
if (!ok) {
toast.error('读取剪贴板失败,请在窗口内直接 Ctrl+V 粘贴')
}
}
function onDocChanged(side: DiffSide): void {
const session = activeFile.value
if (session) session.sides[side].dirty = true
}
function onStats(next: DiffStats): void {
const session = activeFile.value
if (session) session.stats = next
}
// ===== 目录树 → 新文件选项卡 =====
/**
* 点开目录树里的一侧文件:**新开**一个文件选项卡并装载两侧。
*
* 另一侧不存在时留空(该侧 `loaded = false`)—— 「只在一侧有的文件」也值得看内容
* (整篇都会是新增 / 删除),而不是直接告诉用户「无可比」。
*/
async function openPairFromDir(tabId: string, entry: DirDiffEntry): Promise<void> {
await newFileTab({ fromDirTabId: tabId })
const tasks: Promise<void>[] = []
if (entry.leftPath) tasks.push(loadPathInto('a', entry.leftPath))
if (entry.rightPath) tasks.push(loadPathInto('b', entry.rightPath))
await Promise.all(tasks)
syncWindowTitle()
}
/** 返回来源的目录选项卡。 */
function backToSourceDir(): void {
const session = activeFile.value
if (!session?.fromDirTabId) return
void activateTab(session.fromDirTabId)
}
// ===== 拖入:按落点分侧、按当前选项卡类型分派 =====
/** 落点在左半还是右半(拖放坐标是**物理像素**,要除以 DPR 才能与 CSS 宽度比较)。 */
function sideAt(x: number): DiffSide {
const logical = x / (window.devicePixelRatio || 1)
return logical < window.innerWidth / 2 ? 'a' : 'b'
}
function onDropAt(side: DiffSide, paths: string[]): void {
const first = paths[0]
if (!first) return
if (paths.length > 1) logger.info(`拖入 ${paths.length} 项,只取第一个作为该侧目标`)
if (activeDir.value) {
void dirRef.value?.loadDropped(side, first)
return
}
void loadPathInto(side, first)
}
// ===== 关闭确认 =====
/** 窗口关闭:有未保存改动先确认。 */
function doClose(): void {
if (anyDirty.value) {
pendingClose.value = ''
closeConfirmOpen.value = true
return
}
void win.close().catch(() => undefined)
}
async function saveAndClose(): Promise<void> {
const target = pendingClose.value
if (target) {
// 保存某一份会话必须先把它激活:内容只在 CM6 实例里能取到最新值(会话里存的是
// 上次切走时的快照)。激活同时会把**当前**会话的编辑快照回去,不会丢东西。
if (sessions.value.some(s => s.id === target)) await activateTab(target)
}
const ok = target ? await saveAllDirty() : await saveAllDirtyEnsuringFiles()
// 保存失败就不关:**保留确认框**,让用户在「放弃修改并关闭」里明确选择丢弃,
// 而不是默默把改动丢掉(saveSide 已经报过具体原因,这里不再重复提示)。
if (!ok) return
closeConfirmOpen.value = false
pendingClose.value = ''
if (target) removeTab(target)
else void win.close().catch(() => undefined)
}
function discardAndClose(): void {
const target = pendingClose.value
closeConfirmOpen.value = false
pendingClose.value = ''
if (target) removeTab(target)
else void win.close().catch(() => undefined)
}
// ===== 主题(跟随主应用) =====
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
function readMainTheme(): { theme: string; effect: string } {
try {
const raw = localStorage.getItem(STORAGE_KEYS.appSettings)
if (raw) {
const s = JSON.parse(raw) as { theme?: string; effect?: string }
return { theme: s.theme ?? 'system', effect: s.effect ?? 'mica' }
}
} catch {
/* 设置不可读时按默认处理 */
}
return { theme: 'system', effect: 'mica' }
}
function resolveIsDark(theme: string): boolean {
if (theme === 'dark') return true
if (theme === 'light') return false
return window.matchMedia('(prefers-color-scheme: dark)').matches
}
async function applyTheme(): Promise<void> {
const root = document.documentElement
const { theme, effect } = readMainTheme()
const dark = resolveIsDark(theme)
try {
// 原生窗口主题只跟应用主题走(同编辑器窗口的取舍:按自己的配色传值会改写整个
// 应用的 prefers-color-scheme,把托盘菜单等靠 matchMedia 取深浅的窗口带偏)
await win.setTheme(theme === 'system' ? null : (theme as 'dark' | 'light'))
} catch {
/* 平台不支持时忽略 */
}
isDark.value = dark
root.classList.remove('dark', 'effect-mica', 'effect-acrylic', 'effect-normal')
root.classList.add(`effect-${effect}`)
if (dark) root.classList.add('dark')
applyStoredAccent(root, dark ? 'dark' : 'light', STORAGE_KEYS.appSettings)
try {
if (effect === 'mica') {
const micaEffect = (dark ? 'micaDark' : 'micaLight') as unknown as Effect
await win.setEffects({
effects: [micaEffect],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
await win.setBackgroundColor('#00000000')
root.style.setProperty('--popup-bg', 'transparent')
} else if (effect === 'acrylic') {
await win.setEffects({
effects: [Effect.Acrylic],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
await win.setBackgroundColor('#00000000')
root.style.setProperty('--popup-bg', 'transparent')
} else {
const bg = dark ? '#16161a' : '#ffffff'
await win.setBackgroundColor(bg)
root.style.setProperty('--popup-bg', bg)
}
} catch {
/* 忽略效果设置失败 */
}
}
const onThemeChange = () => void applyTheme()
const onStorageChange = (e: StorageEvent) => {
if (e.key === STORAGE_KEYS.appSettings) void applyTheme()
}
// ===== 窗口控制 =====
const doMinimize = () => win.minimize().catch(() => undefined)
const doToggleMaximize = () => win.toggleMaximize().catch(() => undefined)
// ===== 全局按键 =====
/**
* `Ctrl+S` 保存有改动的会话。
*
* 用**捕获阶段**(`true`)注册:焦点在 CM6 里时按键会被编辑器的 keymap 先看到,
* 冒泡阶段可能就到不了 window(同编辑器窗口的做法)。
*/
function onKeydown(event: KeyboardEvent): void {
if (!(event.ctrlKey || event.metaKey)) return
if (event.key.toLowerCase() !== 's') return
event.preventDefault()
void saveAllDirtyEnsuringFiles()
}
/** 打开时带 `?path=`:按类型决定开哪种选项卡(目录 → 目录选项卡,文件 → 文件选项卡)。 */
function initialPath(): string {
const hash = window.location.hash
const index = hash.indexOf('?')
if (index < 0) return ''
return new URLSearchParams(hash.slice(index + 1)).get('path') ?? ''
}
onMounted(async () => {
darkMedia.addEventListener('change', onThemeChange)
window.addEventListener('storage', onStorageChange)
window.addEventListener('keydown', onKeydown, true)
// 主题 → 显示(窗口是隐藏创建的,这一步之后用户才第一次看到它)
await applyTheme()
// 任务栏身份:窗口级 AUMID(独立任务栏按钮,不与主窗口合并)+ 组合图标。
// **必须在 show() 之前** —— 任务栏按钮在窗口显示时按 AUMID 决定分组。
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'diff' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
// 拖入文件 / 文件夹:走 Tauri 原生拖放事件(drop 取 paths),落点决定装入哪一侧。
const selfWebview = getCurrentWebview()
unlistenDragDrop = await selfWebview.onDragDropEvent(event => {
const payload = event.payload
if (payload.type === 'enter' || payload.type === 'over') {
dragSide.value = sideAt(payload.position.x)
} else if (payload.type === 'drop') {
const side = sideAt(payload.position.x)
dragSide.value = null
onDropAt(side, payload.paths)
} else {
dragSide.value = null
}
})
try {
await win.show()
await win.setFocus()
} catch (e) {
logger.warn(`显示对比窗口失败:${String(e)}`)
}
// 模块设置(目录对比的两个默认开关取自这里)
try {
settings.value = await diffClient.getSettings()
} catch (e) {
logger.warn(`读取对比设置失败:${String(e)}`)
}
// 首个选项卡:先恢复上次会话(若有),再处理「带目标打开」——目标作为**追加**的选项卡
// 打开,而不是把上次的会话冲掉(同编辑器「打开文件」的取舍)。都没有历史时给一个空的
// 文件会话(与 Beyond Compare 的「新建会话」一致,落地即可用)。
const restored = await restoreSession()
const target = initialPath()
if (target) {
const kind = await diffClient.pathKind(target).catch(() => 'missing' as const)
if (kind === 'dir') {
await newDirTab({ leftRoot: target }, false)
} else {
await newFileTab()
await loadPathInto('a', target)
}
} else if (!restored) {
await newFileTab()
}
})
onBeforeUnmount(() => {
darkMedia.removeEventListener('change', onThemeChange)
window.removeEventListener('storage', onStorageChange)
window.removeEventListener('keydown', onKeydown, true)
unlistenDragDrop?.()
unlistenDragDrop = null
// 会话:先落一次最终快照(防抖可能还挂着一笔没写)
if (sessionTimer) {
clearTimeout(sessionTimer)
sessionTimer = null
}
saveSession()
})
</script>
<template>
<div class="diff-window relative flex h-screen flex-col overflow-hidden text-foreground">
<!-- 自绘标题栏:仅标题区是拖动区(按钮区不能被拖动拦截鼠标事件) -->
<header class="flex h-9 shrink-0 items-center gap-1 border-b border-border px-2">
<div class="flex h-full min-w-0 flex-1 items-center gap-2 pl-1" data-tauri-drag-region>
<Diff class="size-3.5 shrink-0 text-primary" />
<span class="pointer-events-none truncate text-xs font-medium">
{{ active ? sessionTitle(active) : '对比' }}
</span>
</div>
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="doMinimize">
<Minus class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">最小化</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="doToggleMaximize">
<Square class="size-3" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">最大化 / 还原</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button
variant="ghost"
size="icon-sm"
class="hover:!bg-destructive hover:!text-destructive-foreground"
@click="doClose"
>
<X class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">关闭窗口</TooltipContent>
</Tooltip>
</TooltipProvider>
</header>
<!-- 选项卡栏:每个选项卡是一对目标(左 ↔ 右)。样式对齐编辑器窗口的标签栏
(选中标签 = 主题色下边框 + 选中底色) -->
<div class="flex h-8 shrink-0 items-stretch border-b border-border">
<div class="flex min-w-0 flex-1 items-stretch gap-0.5 overflow-x-auto px-1">
<div
v-for="session in sessions"
:key="session.id"
class="group flex max-w-60 min-w-0 shrink-0 cursor-pointer items-center gap-1.5 rounded-t-sm border-b-2 px-2 text-xs transition-colors duration-150"
:class="
session.id === activeId
? 'border-primary bg-row-selected text-foreground'
: 'border-transparent text-fg-secondary hover:bg-row-hover hover:text-foreground'
"
@click="activateTab(session.id)"
>
<FolderTree v-if="session.kind === 'dirs'" class="size-3 shrink-0 opacity-70" />
<FileText v-else class="size-3 shrink-0 opacity-70" />
<span class="truncate">{{ sessionTitle(session) }}</span>
<span v-if="fileSessionHasDirty(session)" class="size-1.5 shrink-0 rounded-full bg-primary" />
<button
type="button"
class="flex size-4 shrink-0 items-center justify-center rounded-sm text-muted-foreground opacity-0 transition-opacity hover:bg-hover hover:text-foreground group-hover:opacity-100"
title="关闭选项卡"
@click.stop="requestCloseTab(session.id)"
>
<X class="size-3" />
</button>
</div>
</div>
<div class="flex shrink-0 items-center gap-0.5 px-1">
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button
variant="ghost"
size="icon-sm"
@click="newFileTab({ fromDirTabId: '' })"
>
<FilePlus2 class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">新建文件对比选项卡</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="newDirTab()">
<FolderTree class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">新建文件夹对比选项卡</TooltipContent>
</Tooltip>
</TooltipProvider>
</div>
</div>
<!-- ===== 文件 / 文本选项卡 ===== -->
<template v-if="activeFile">
<!-- 工具栏:粘贴 / 交换 / 差异导航 / 清空(差异块的左右搬运改用两侧行号旁的箭头) -->
<div class="flex h-9 shrink-0 items-center gap-1 border-b border-border bg-background px-2">
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="pasteInto('a')">
<ClipboardPaste class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">粘贴到左侧(原始)</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="pasteInto('b')">
<ClipboardPaste class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">粘贴到右侧(对比)</TooltipContent>
</Tooltip>
</TooltipProvider>
<div class="mx-1 h-4 w-px shrink-0 bg-border" />
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="swapSides">
<ArrowLeftRight class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">交换左右内容</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="moveChunk(-1)">
<ChevronUp class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">上一处差异</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="moveChunk(1)">
<ChevronDown class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">下一处差异</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="clearAll">
<Eraser class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">清空两侧(含文件关联)</TooltipContent>
</Tooltip>
</TooltipProvider>
<div class="mx-1 h-4 w-px shrink-0 bg-border" />
<Button
v-if="activeFile.fromDirTabId"
variant="outline"
size="sm"
class="ml-2 h-7"
@click="backToSourceDir"
>
<ChevronLeft class="size-3.5" />返回目录对比
</Button>
<span class="ml-2 truncate text-[11px] text-muted-foreground">
行号左边的 → / ← 可把该差异块整块搬到对面;把文件拖到左 / 右半边即可装入该侧
</span>
</div>
<!-- 两侧头部:打开 / 保存 / 编码 / 只读 -->
<div class="flex h-8 shrink-0 items-stretch border-b border-border bg-background">
<div
v-for="side in SIDES"
:key="side"
class="flex min-w-0 flex-1 items-center gap-1.5 px-2"
:class="side === 'b' ? 'border-l border-border' : ''"
>
<FileText class="size-3.5 shrink-0 text-muted-foreground" />
<span class="truncate text-xs font-medium" :title="fileSides[side].path || undefined">
{{ fileSides[side].loaded ? fileSides[side].name : side === 'a' ? '原始文本' : '对比文本' }}
</span>
<span
v-if="fileSides[side].dirty"
class="size-1.5 shrink-0 rounded-full bg-primary"
title="有未保存改动"
/>
<span
v-if="fileSides[side].encoding"
class="shrink-0 rounded-sm bg-subtle px-1 py-0.5 text-[10px] uppercase text-muted-foreground"
>
{{ fileSides[side].encoding }}
</span>
<span
v-if="fileSides[side].readonly && !fileSides[side].binary"
class="shrink-0 rounded-sm bg-warning-soft px-1 py-0.5 text-[10px] text-warning-text"
>
只读
</span>
<div class="ml-auto flex shrink-0 items-center gap-0.5">
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="openSide(side)">
<FolderOpen class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">打开文件到{{ side === 'a' ? '左' : '右' }}侧</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button
variant="ghost"
size="icon-sm"
:disabled="!fileSides[side].dirty || fileSides[side].readonly"
@click="saveSide(side)"
>
<Save class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">保存这一侧(Ctrl+S)</TooltipContent>
</Tooltip>
</TooltipProvider>
</div>
</div>
</div>
<!-- 主体:差异视图 / 二进制概览 -->
<div class="relative flex min-h-0 flex-1 flex-col bg-background">
<TextMergeView
v-if="showMerge"
ref="mergeRef"
:is-dark="isDark"
:large="fileSides.a.large || fileSides.b.large"
@stats="onStats"
@doc-changed="onDocChanged"
/>
<!-- 二进制:不渲染 diff,只并列显示元信息并比较大小 -->
<div v-else class="flex min-h-0 flex-1">
<div
v-for="side in SIDES"
:key="side"
class="flex min-w-0 flex-1 flex-col items-center justify-center gap-2 px-4 text-center"
:class="side === 'b' ? 'border-l border-border' : ''"
>
<FileText class="size-5 text-muted-foreground" />
<span class="max-w-full truncate text-xs font-medium">
{{ fileSides[side].name || '(空)' }}
</span>
<span class="text-[11px] text-muted-foreground">{{ formatSize(fileSides[side].size) }}</span>
<span class="rounded-sm bg-subtle px-1.5 py-0.5 text-[10px] text-muted-foreground">二进制</span>
</div>
</div>
<!-- 拖入落点高亮 -->
<div v-if="dragSide" class="pointer-events-none absolute inset-0 z-40 flex">
<div
v-for="side in SIDES"
:key="side"
class="m-2 flex flex-1 items-center justify-center rounded-lg"
:class="dragSide === side ? 'border-2 border-dashed border-primary bg-background/60' : 'opacity-0'"
>
<span class="text-sm font-medium text-primary">
松开以载入{{ side === 'a' ? '左' : '右' }}侧
</span>
</div>
</div>
</div>
<!-- 状态栏 -->
<footer
class="flex h-7 shrink-0 items-center gap-3 border-t border-border bg-background px-3 text-[11px] text-muted-foreground"
>
<template v-if="showMerge">
<span class="tabular-nums">差异 {{ activeFile.stats.chunks }} 处</span>
<span v-if="activeFile.stats.chunks" class="tabular-nums text-success-text">
+{{ activeFile.stats.addedLines }} 行
</span>
<span v-if="activeFile.stats.chunks" class="tabular-nums text-danger-text">
-{{ activeFile.stats.removedLines }} 行
</span>
</template>
<span v-else class="text-warning-text">
两侧均为二进制文件,仅比较大小:{{ binarySameSize ? '大小相同' : '大小不同' }}
</span>
<span v-if="encodingMismatch" class="truncate text-warning-text">
编码不一致({{ fileSides.a.encoding }} vs {{ fileSides.b.encoding }})—— 差异可能只是解码不同
</span>
<span class="ml-auto shrink-0 tabular-nums">
左侧 {{ activeFile.stats.linesA }} 行 · 右侧 {{ activeFile.stats.linesB }} 行
</span>
</footer>
</template>
<!-- ===== 文件夹选项卡 ===== -->
<div v-else-if="activeDir" class="relative flex min-h-0 flex-1 flex-col">
<DirDiffView
ref="dirRef"
v-model:session="dirModel"
@open-file="payload => openPairFromDir(activeDir!.id, payload.entry)"
/>
<!-- 目录选项卡的拖入提示:整块高亮 -->
<div
v-if="dragSide"
class="pointer-events-none absolute inset-0 z-40 flex items-center justify-center border-2 border-dashed border-primary bg-background/60"
>
<span class="text-sm font-medium text-primary">
松开以载入{{ dragSide === 'a' ? '左' : '右' }}侧目录
</span>
</div>
</div>
<!--
关闭确认:三选一(保存并关闭 / 放弃修改并关闭 / 取消)。
不用 ConfirmDialog —— 它只有「确认 / 取消」两键,而「放弃修改」是用户在这里最常
需要的那条出路,不能藏在「取消」里(同编辑器窗口的取舍)。
-->
<Dialog :open="closeConfirmOpen" @update:open="closeConfirmOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>{{ pendingClose ? '该选项卡有未保存的改动' : '有未保存的改动' }}</DialogTitle>
<DialogDescription>
「保存并关闭」会把改动按各自的编码与换行写回对应文件;「放弃修改并关闭」直接丢弃
这些改动,无法恢复。
</DialogDescription>
</DialogHeader>
<DialogFooter class="flex-col gap-2 sm:flex-col sm:space-x-0">
<Button class="w-full" @click="saveAndClose">保存并关闭</Button>
<Button variant="destructive" class="w-full" @click="discardAndClose">
放弃修改并关闭
</Button>
<Button variant="ghost" class="w-full" @click="closeConfirmOpen = false">取消</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<Toaster />
</div>
</template>
<style scoped>
/* 窗口根容器:mica/acrylic 下透明,普通模式用不透明底色(--popup-bg 由 applyTheme 写入) */
.diff-window {
background: var(--popup-bg, var(--background));
}
</style>