编辑调整、对比模块

This commit is contained in:
zhongluofeng committed 2026-10-16 13:18:32 +08:00
1 parent c9e61f38c5
commit 6cfa74c901
76 files changed
+9514 -626

No files matched your search

+1 -1
View File
@@ -89,7 +89,7 @@ watch(selectedId, () => {
p-5 属于**滚动内容**(模块根在主滚动区内部),因此卡片阴影四周都有余量,
不再需要任何负外边距补偿。
工具自身需要限高的地方(正则结果、diff 输出等)仍保留各自的 `max-h-*` 内滚动
工具自身需要限高的地方(正则结果等)仍保留各自的 `max-h-*` 内滚动
盒子 —— 那是「一块有边界的输出区」,与页面级滚动不是一回事。
-->
<div class="min-h-full p-5 flex flex-col">
+1 -1
View File
@@ -14,7 +14,7 @@ export const moduleConfig: ModuleConfig = {
id: 'devtools',
name: '开发者工具',
icon: 'devtools',
description: 'JSON / Base64 / 时间戳 / 正则 / 颜色 / Cron / 密码等 20 个常用开发工具',
description: 'JSON / Base64 / 时间戳 / 正则 / 颜色 / Cron / 密码等 19 个常用开发工具',
category: 'tool',
defaultEnabled: true,
loader: () => import('./DevToolsModule.vue'),
-146
View File
@@ -1,146 +0,0 @@
<script setup lang="ts">
import { computed, ref } from 'vue'
import { Textarea } from '@/components/ui/textarea'
import { Label } from '@/components/ui/label'
import ResultArea from '../components/ResultArea.vue'
const oldText = ref('')
const newText = ref('')
type Op = 'equal' | 'del' | 'add'
interface DiffLine {
op: Op
oldLine: string
line: string
newLine: string
}
// LCS DP 为 O(n·m),行数过大会卡死 UI;超过上限停止计算并提示
const MAX_LINES = 3000
// 先裁剪公共前缀/后缀,LCS 只算中间差异部分(典型场景提速明显)
function diffLines(a: string[], b: string[]): DiffLine[] {
const out: DiffLine[] = []
let start = 0
while (start < a.length && start < b.length && a[start] === b[start]) {
out.push({ op: 'equal', oldLine: a[start], line: a[start], newLine: b[start] })
start++
}
let endA = a.length, endB = b.length
while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
endA--
endB--
}
const mid = lcsDiff(a.slice(start, endA), b.slice(start, endB))
// 后缀公共部分:a[endA..] 与 b[endB..] 逐行配对
const suffix: DiffLine[] = []
for (let i = a.length - 1; i >= endA; i--) {
const j = endB + (i - endA)
suffix.unshift({ op: 'equal', oldLine: a[i], line: a[i], newLine: b[j] })
}
return [...out, ...mid, ...suffix]
}
function lcsDiff(a: string[], b: string[]): DiffLine[] {
const n = a.length
const m = b.length
if (n === 0) return b.map(line => ({ op: 'add' as const, oldLine: '', line, newLine: '' }))
if (m === 0) return a.map(line => ({ op: 'del' as const, oldLine: line, line, newLine: '' }))
// LCS DP
const dp: number[][] = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0))
for (let i = n - 1; i >= 0; i--) {
for (let j = m - 1; j >= 0; j--) {
dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1])
}
}
const out: DiffLine[] = []
let i = 0
let j = 0
while (i < n && j < m) {
if (a[i] === b[j]) {
out.push({ op: 'equal', oldLine: a[i], line: a[i], newLine: b[j] })
i++
j++
} else if (dp[i + 1][j] >= dp[i][j + 1]) {
out.push({ op: 'del', oldLine: a[i], line: a[i], newLine: '' })
i++
} else {
out.push({ op: 'add', oldLine: '', line: b[j], newLine: b[j] })
j++
}
}
while (i < n) {
out.push({ op: 'del', oldLine: a[i], line: a[i], newLine: '' })
i++
}
while (j < m) {
out.push({ op: 'add', oldLine: '', line: b[j], newLine: b[j] })
j++
}
return out
}
const tooLarge = computed(() =>
oldText.value.split('\n').length > MAX_LINES || newText.value.split('\n').length > MAX_LINES
)
const lines = computed(() => {
if (tooLarge.value) return []
return diffLines(oldText.value.split('\n'), newText.value.split('\n'))
})
const stats = computed(() => {
let adds = 0
let dels = 0
for (const l of lines.value) {
if (l.op === 'add') adds++
else if (l.op === 'del') dels++
}
return { adds, dels }
})
const unifiedText = computed(() => {
if (lines.value.length === 0) return ''
return lines.value
.map(l => (l.op === 'add' ? '+' : l.op === 'del' ? '-' : ' ') + l.line)
.join('\n')
})
</script>
<template>
<div class="flex flex-col gap-4">
<div class="grid grid-cols-2 gap-3">
<div class="flex flex-col gap-1.5">
<Label class="text-xs text-danger">旧文本(删除 {{ stats.dels }} 行)</Label>
<Textarea v-model="oldText" placeholder="旧文本..." class="min-h-[140px] font-mono text-xs resize-y" />
</div>
<div class="flex flex-col gap-1.5">
<Label class="text-xs text-success">新文本(新增 {{ stats.adds }} 行)</Label>
<Textarea v-model="newText" placeholder="新文本..." class="min-h-[140px] font-mono text-xs resize-y" />
</div>
</div>
<div class="flex flex-col gap-1.5">
<Label class="text-xs">差异预览</Label>
<div class="rounded-md border border-border max-h-64 overflow-auto font-mono text-xs leading-relaxed">
<div v-if="tooLarge" class="p-3 text-destructive">文本超过 {{ MAX_LINES }} 行,差异计算已停止(LCS 算法复杂度 O(n·m)),请缩减输入。</div>
<div v-else-if="lines.length === 0 || (oldText === '' && newText === '')" class="p-3 text-muted-foreground">输入两边文本查看差异。</div>
<div
v-for="(l, i) in lines"
:key="i"
class="flex whitespace-pre px-2 py-0.5"
:class="{
'bg-danger-soft text-danger-text': l.op === 'del',
'bg-success-soft text-success-text': l.op === 'add',
'text-muted-foreground': l.op === 'equal'
}"
>
<span class="w-5 shrink-0 select-none">{{ l.op === 'add' ? '+' : l.op === 'del' ? '-' : ' ' }}</span>
<span class="break-all">{{ l.line }}</span>
</div>
</div>
</div>
<ResultArea :text="unifiedText" label="统一格式(可复制)" placeholder="unified diff" />
</div>
</template>
+1 -8
View File
@@ -2,7 +2,7 @@ import type { Component } from 'vue'
import { defineAsyncComponent } from 'vue'
import {
FileJson, Binary, Link, Clock, MoveHorizontal, Fingerprint,
Wand2, KeyRound, CaseSensitive, Hash, Code, GitCompare, Shield,
Wand2, KeyRound, CaseSensitive, Hash, Code, Shield,
Palette, Lock, CalendarClock, Network, Sigma, Replace, Globe
} from '@lucide/vue'
import { registerTool, type DevTool } from '../registry'
@@ -69,11 +69,6 @@ export const TOOLS_META: Array<Omit<DevTool, 'component' | 'icon'>> = [
description: '在线测试正则表达式,实时匹配、分组查看与替换预览',
keywords: ['正则', 'regex', '匹配', 'test', 're', '替换']
},
{
id: 'diff', name: '文本对比', category: 'text',
description: '两段文本逐行差异对比',
keywords: ['对比', '差异', 'diff', '比较', 'compare']
},
{
id: 'eol', name: '行尾符转换', category: 'text',
description: 'CRLF / LF / CR 行尾符统一',
@@ -125,7 +120,6 @@ const TOOL_ICONS: Record<string, Component> = {
escape: Code,
case: CaseSensitive,
regex: Wand2,
diff: GitCompare,
eol: MoveHorizontal,
replace: Replace,
charcount: Sigma,
@@ -149,7 +143,6 @@ const TOOL_COMPONENTS: Record<string, () => Promise<{ default: Component }>> = {
escape: () => import('./EscapeTools.vue'),
case: () => import('./CaseTools.vue'),
regex: () => import('./RegexTools.vue'),
diff: () => import('./DiffTools.vue'),
eol: () => import('./EolTools.vue'),
replace: () => import('./ReplaceTools.vue'),
charcount: () => import('./CharCountTools.vue'),
+172
View File
@@ -0,0 +1,172 @@
<script setup lang="ts">
/**
* 对比工具主模块页(主窗口内)。
*
* 真正的对比发生在独立窗口(`openWindow.ts`),本页只负责入口、进度说明与设置 ——
* 与编辑器模块「主模块页做设置与入口、编辑发生在独立窗口」同一分工。
*
* 设置项少(只有一个快捷键 + 两个目录对比默认值),因此直接从 Rust 读写,不再单独建
* store:`diff_get_settings` / `diff_save_settings` 一次往返就够,且保存后后端会就地
* 重注册快捷键,「改完立刻生效」不需要前端额外做什么。
*/
import { onMounted, ref } from 'vue'
import { Diff, FileText, FolderTree, Rows2 } from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Button } from '@/components/ui/button'
import { Card, CardContent } from '@/components/ui/card'
import { Input } from '@/components/ui/input'
import { Switch } from '@/components/ui/switch'
import { SettingGroup, SettingRow } from '@/components/common'
import { diffClient } from './diffClient'
import { openDiffWindow } from './openWindow'
import type { DiffSettings } from './types'
/** 三种对比能力。 */
const LEVELS = [
{
id: 'text',
name: '文本对比',
icon: Rows2,
description: '两段文本并排对照,块级高亮差异,可上下跳转',
available: true
},
{
id: 'file',
name: '文件对比',
icon: FileText,
description: '两个磁盘文件并排对照,自动探测编码(GBK / Shift_JIS / UTF-8…),支持拖入与单侧写回',
available: true
},
{
id: 'folder',
name: '文件夹对比',
icon: FolderTree,
description: '左右两棵结构树,递归比对:仅左侧有 / 仅右侧有 / 内容不同(只读,不做写回)',
available: true
}
]
const settings = ref<DiffSettings | null>(null)
async function openDiff(): Promise<void> {
try {
await openDiffWindow()
} catch (e) {
toast.error(`打开对比窗口失败:${String(e)}`)
}
}
/** 提交一处设置改动(后端保存后会就地重注册快捷键)。 */
async function commit(patch: Partial<DiffSettings>): Promise<void> {
const current = settings.value
if (!current) return
try {
settings.value = await diffClient.saveSettings({ ...current, ...patch })
} catch (e) {
toast.error(`保存失败:${String(e)}`)
}
}
onMounted(async () => {
try {
settings.value = await diffClient.getSettings()
} catch (e) {
toast.error(`读取设置失败:${String(e)}`)
}
})
</script>
<template>
<div class="min-h-full p-5">
<div class="flex flex-col gap-4">
<!-- 状态与入口 -->
<Card class="!py-0 !gap-0">
<CardContent class="flex flex-wrap items-center gap-x-6 gap-y-3 px-4 py-4">
<div class="flex items-center gap-2.5">
<span class="flex items-center gap-1.5 text-[13px] text-fg-secondary">
<span class="size-2 rounded-full bg-success" />三层均已可用
</span>
<span class="text-[13px] text-fg-secondary">文本 · 文件 · 文件夹对比</span>
</div>
<div class="flex min-w-0 flex-1 flex-col gap-0.5">
<span class="text-[11px] text-muted-foreground">当前范围</span>
<span class="truncate text-[13px] text-fg-secondary">
目录对比为只读(不做写回 / 同步)
</span>
</div>
<div class="ml-auto flex flex-wrap gap-2">
<Button size="sm" @click="openDiff">
<Diff class="size-3.5" />打开对比窗口
</Button>
</div>
</CardContent>
</Card>
<!-- 三种对比层级 -->
<Card class="!gap-2 !py-4">
<CardContent class="flex flex-col divide-y divide-divider !px-4">
<div
v-for="level in LEVELS"
:key="level.id"
class="flex items-center gap-4 py-3 first:pt-0 last:pb-0"
>
<div
class="flex size-8 shrink-0 items-center justify-center rounded-lg bg-primary-soft text-primary-soft-text"
>
<component :is="level.icon" class="size-4" />
</div>
<div class="flex min-w-0 flex-1 flex-col gap-0.5">
<span class="text-[13px] text-foreground">{{ level.name }}</span>
<span class="truncate text-xs text-muted-foreground">{{ level.description }}</span>
</div>
<span class="shrink-0 rounded-sm bg-success-soft px-1.5 py-0.5 text-[10px] text-success-text">
可用
</span>
</div>
</CardContent>
</Card>
<!-- 设置(改动即时生效,无保存按钮) -->
<SettingGroup
v-if="settings"
title="对比窗口"
description="快捷键与目录对比的默认行为;改动即时生效,无需保存"
>
<SettingRow
label="打开对比窗口"
description="全局快捷键,任意模块下都可用;留空则不注册"
control-width="wide"
>
<Input
:model-value="settings.openDiffShortcut"
placeholder="Alt+C"
spellcheck="false"
@change="(e: Event) => commit({ openDiffShortcut: (e.target as HTMLInputElement).value })"
/>
</SettingRow>
<SettingRow
label="目录对比默认比对内容"
description="大小相同但时间戳不同时,读文件内容逐字节比对(更准,也更慢)"
>
<Switch
:model-value="settings.compareContent"
@update:model-value="v => commit({ compareContent: v === true })"
/>
</SettingRow>
<SettingRow
label="目录对比默认跳过构建目录"
description="跳过 node_modules / .git / target 等目录,避免把无关目录也扫一遍"
>
<Switch
:model-value="settings.skipBuildDirs"
@update:model-value="v => commit({ skipBuildDirs: v === true })"
/>
</SettingRow>
</SettingGroup>
</div>
</div>
</template>
File diff suppressed because it is too large. Load diff
+981
View File
@@ -0,0 +1,981 @@
<script setup lang="ts">
/**
* 目录对比视图(**只读**):左右两棵结构树。
*
* # 为什么是两棵树,而不是一棵并集树
*
* 第一版是一棵「三态并集树」(每行用一种颜色标 仅左 / 仅右 / 不同)。但对比工具的心智
* 模型是「左边是一个目录、右边是另一个目录」—— 参考 Beyond Compare:两边各自一棵树、
* 各自一列大小与修改时间,人一眼就能看出「这个文件只在右边有」。因此这里**两个结构树
* 渲染同一份并集行**(行数、顺序完全一致,共用折叠状态),只是每一侧的单元格只显示该侧
* 真实存在的文件(另一侧缺失时显示为「—」并把名字压暗)。
*
* 共用一份行列表还有两个好处:左右永远不错行;将来做「滚动联动」时不需要额外对齐逻辑。
*
* # 会话状态是「共享可变模型」
*
* 状态由 `DiffWindow` 持有(一个选项卡一份),本组件直接读写传入的 `session` —— 理由见
* `types.ts` 的 `DirSessionState` 注释(8 个字段几乎都双向改,拆成 props/emits 会得到
* 十几个定义,而它们本来就是同一个东西)。
*
* # 点击任意一侧的文件 → 新开一个文件对比选项卡
*
* 这符合 Beyond Compare 的用法:在目录级先定位「哪个文件不一样」,再下钻到内容级。
* 只在一侧存在的文件也可以开(另一侧为空,整篇都是新增/删除)。
*/
import { computed, markRaw, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
import { open } from '@tauri-apps/plugin-dialog'
import { ChevronDown, ChevronRight, FolderOpen, Loader2, RefreshCw } from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { ScrollArea } from '@/components/ui/scroll-area'
import { StateBlock } from '@/components/common'
import { EVENTS } from '@/lib/constants'
import { diffClient } from '../diffClient'
import type {
DiffScanProgress,
DiffSide,
DirDiffEntry,
DirFilterId,
DirSessionState
} from '../types'
/**
* 会话状态:用 `v-model:session` 而不是普通 prop。
*
* 本组件要**直接改**会话字段(根路径、过滤、折叠、扫描结果…),而 Vue 的
* `vue/no-mutating-props` 明确禁止改 prop。`defineModel` 拿到的是本地 model 引用
* (与父组件共享同一个响应式对象),改它的**字段**是合法且惯用的做法 —— 父组件那边
* 用 getter-only 的 computed 提供句柄即可(子组件从不整体替换会话,只改字段)。
*/
const session = defineModel<DirSessionState>('session', { required: true })
const emit = defineEmits<{
/** 点击某一侧的文件 → 由 DiffWindow 新开一个文件对比选项卡 */
'open-file': [payload: { side: DiffSide; entry: DirDiffEntry }]
}>()
const SIDES: readonly DiffSide[] = ['a', 'b']
/**
* 默认跳过的目录名(**唯一事实来源在这里**)。
*
* 与 `editor` 模块的默认跳过清单保持一致:同一台机器上「哪些目录不值得看」是同一个
* 判断,两个功能给出不同的默认值会让人困惑。后端只接收这份清单并按它执行。
*/
const DEFAULT_SKIP_DIRS =
'debug|.vs|.git|.svn|.hg|.idea|.vscode|node_modules|target|dist|build|out|.cache|__pycache__|.venv|venv|vendor|.next|coverage|.tmp-build'
.split('|')
const FILTERS: Array<{ id: DirFilterId; label: string }> = [
{ id: 'diff', label: '仅差异' },
{ id: 'all', label: '全部' },
{ id: 'left-only', label: '仅左侧' },
{ id: 'right-only', label: '仅右侧' }
]
const ready = computed(() => !!session.value.leftRoot && !!session.value.rightRoot)
function rootOf(side: DiffSide): string {
return side === 'a' ? session.value.leftRoot : session.value.rightRoot
}
/** 输入框回车 / 失焦即生效(失焦只有值变了才写,避免无意义的重扫)。 */
function onRootInput(side: DiffSide, event: Event): void {
const value = (event.target as HTMLInputElement).value
if (value === rootOf(side)) return
setRoot(side, value)
}
/**
* 输入框回车。
*
* 值有改动时**什么都不做**:回车随后会触发 `change`,由它提交并(两侧就绪时)扫描。
* 若这里也顺手扫一次,就会先用**旧**根路径白扫一遍(`keydown` 早于 `change`,此刻
* 会话里的根还是旧值),表现为「按回车闪一下旧结果再换成新的」。
* 值没改时回车 = 重新扫描(这是用户按回车的常见意图)。
*/
function onRootEnter(side: DiffSide, event: KeyboardEvent): void {
const value = (event.target as HTMLInputElement).value
if (value !== rootOf(side)) return
void compare()
}
/** 图标按钮:系统对话框选目录。 */
async function browse(side: DiffSide): Promise<void> {
try {
const selected = await open({ directory: true, multiple: false, title: '选择要对比的文件夹' })
if (typeof selected !== 'string') return
setRoot(side, selected)
} catch (e) {
toast.error(`选择文件夹失败:${String(e)}`)
}
}
/** 设定某一侧的根;两侧都就绪时自动开始扫描。 */
function setRoot(side: DiffSide, path: string): void {
if (side === 'a') session.value.leftRoot = path
else session.value.rightRoot = path
if (ready.value) void compare()
}
/**
* 拖入一个路径:目录直接作为该侧根;文件则取其**所在目录**
* (拖一个文件进来想比的是它所在的目录结构,而不是报错)。
*/
async function loadDropped(side: DiffSide, path: string): Promise<void> {
let target = path
try {
if ((await diffClient.pathKind(path)) === 'file') target = parentDir(path)
} catch {
/* 探测失败就按原路径试,让 compare 给出明确错误 */
}
setRoot(side, target)
}
/** 取父目录(同时兼容 `\` 与 `/`)。 */
function parentDir(path: string): string {
const trimmed = path.replace(/[\\/]+$/, '')
const index = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'))
return index > 0 ? trimmed.slice(0, index) : trimmed
}
/** 本轮扫描的序号(进度事件按它过滤,见 `compare`)。 */
let scanSeq = 0
/** 当前扫描的进度(`null` = 还没收到第一帧,界面显示「扫描中…」)。 */
const scanProgress = ref<DiffScanProgress | null>(null)
let unlistenProgress: UnlistenFn | null = null
/** 进度文案(`null` = 还没收到进度帧)。 */
const progressText = computed(() => {
const p = scanProgress.value
if (!p) return null
const label = p.phase === 'compare' ? '正在核对内容' : '已遍历'
return p.total ? `${label} ${p.done} / ${p.total}` : `${label} ${p.done} 项`
})
async function compare(): Promise<void> {
if (!ready.value) return
session.value.scanning = true
// 每轮扫描一个新的 id:进度事件是**全局**的(Rust 侧不区分选项卡),用一个自增 id
// 把别人的进度过滤掉 —— 否则切到另一个正在扫的目录选项卡时会看到对不上的计数。
const id = ++scanSeq
scanProgress.value = null
try {
const report = await diffClient.compareDirs(
id,
session.value.leftRoot,
session.value.rightRoot,
session.value.skipBuild ? DEFAULT_SKIP_DIRS : [],
session.value.compareContent
)
// markRaw:条目可达数千,让它进响应式系统会逐条生成 Proxy(纯开销)
session.value.report = markRaw(report)
session.value.collapsed = new Set()
} catch (e) {
session.value.report = null
toast.error(`目录对比失败:${String(e)}`)
} finally {
session.value.scanning = false
scanProgress.value = null
}
}
// ===== 树 =====
interface TreeNode {
relPath: string
name: string
depth: number
isDir: boolean
entry: DirDiffEntry | null
children: TreeNode[]
/** 自身或子树里是否有「值得显示」的条目 */
significant: boolean
}
function matches(entry: DirDiffEntry): boolean {
switch (session.value.filter) {
case 'all':
return true
case 'diff':
return entry.status === 'different' || entry.status === 'type-mismatch'
case 'left-only':
return entry.status === 'left-only'
case 'right-only':
return entry.status === 'right-only'
}
}
/** 由扁平条目组装成树(缺失的中间目录会被补齐,避免因截断 / 跳过而丢上下文)。 */
function buildTree(entries: DirDiffEntry[]): TreeNode {
const root: TreeNode = {
relPath: '',
name: '',
depth: 0,
isDir: true,
entry: null,
children: [],
significant: false
}
const map = new Map<string, TreeNode>([['', root]])
const ensure = (relPath: string): TreeNode => {
const existing = map.get(relPath)
if (existing) return existing
const cut = relPath.lastIndexOf('/')
const name = cut < 0 ? relPath : relPath.slice(cut + 1)
const parent = ensure(cut < 0 ? '' : relPath.slice(0, cut))
const node: TreeNode = {
relPath,
name,
depth: parent.depth + 1,
isDir: false,
entry: null,
children: [],
significant: false
}
parent.children.push(node)
map.set(relPath, node)
return node
}
for (const entry of entries) {
const node = ensure(entry.relPath)
node.entry = entry
node.isDir = entry.isDir
}
// 目录在前、同级按名字排序(与资源管理器的观感一致)
for (const node of map.values()) {
node.children.sort((a, b) => {
if (a.isDir !== b.isDir) return a.isDir ? -1 : 1
return a.name.localeCompare(b.name)
})
}
return root
}
/** 自底向上标注「这一支有没有值得显示的东西」。 */
function markSignificant(node: TreeNode): boolean {
let childSignificant = false
for (const child of node.children) {
// 注意顺序:先递归再取返回值,不能短路(短路会让后面的分支不被标注)
if (markSignificant(child)) childSignificant = true
}
node.significant = childSignificant || (node.entry ? matches(node.entry) : false)
return node.significant
}
/** 由扁平条目组装成的树(只随扫描结果变化;过滤条件不影响它的结构)。 */
const builtTree = computed<TreeNode>(() => {
const current = session.value.report
return buildTree(current ? current.entries : [])
})
/**
* 带「值得显示」标注的树。
*
* 与 `builtTree` 拆开,是为了**不让过滤条件的变化触发整棵树的重新组装**:`buildTree` 是
* O(条目数) 的分配 + 排序,而 `markSignificant` 只是在既有节点上重算一个布尔量。原来两步
* 挤在同一个 computed 里,点一下「仅差异 / 仅左侧」就要把全部节点重新建一遍。
*/
const tree = computed<TreeNode>(() => {
const root = builtTree.value
markSignificant(root)
return root
})
/** 展平成可渲染的行(跳过被剪掉的与折叠的)。左右两个结构树共用这份行。 */
const rows = computed<Array<{ node: TreeNode; depth: number }>>(() => {
const out: Array<{ node: TreeNode; depth: number }> = []
const collapsed = session.value.collapsed
const walk = (node: TreeNode): void => {
for (const child of node.children) {
if (!child.significant) continue
out.push({ node: child, depth: child.depth })
if (child.isDir && !collapsed.has(child.relPath)) walk(child)
}
}
walk(tree.value)
return out
})
function toggleDir(relPath: string): void {
const next = new Set(session.value.collapsed)
if (next.has(relPath)) next.delete(relPath)
else next.add(relPath)
session.value.collapsed = next
}
/** 展开 / 折叠全部目录。 */
function setAllCollapsed(value: boolean): void {
if (!value) {
session.value.collapsed = new Set()
return
}
const keys = new Set<string>()
const walk = (node: TreeNode): void => {
for (const child of node.children) {
if (child.isDir && child.children.length) keys.add(child.relPath)
walk(child)
}
}
walk(tree.value)
session.value.collapsed = keys
}
// ===== 汇总 =====
const summary = computed(() => {
const counts = { different: 0, leftOnly: 0, rightOnly: 0, identical: 0, mismatch: 0 }
for (const entry of session.value.report?.entries ?? []) {
if (entry.isDir) {
if (entry.status === 'type-mismatch') counts.mismatch++
continue
}
if (entry.status === 'different') counts.different++
else if (entry.status === 'left-only') counts.leftOnly++
else if (entry.status === 'right-only') counts.rightOnly++
else if (entry.status === 'identical') counts.identical++
}
return counts
})
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`
}
function formatTime(ms: number): string {
if (!ms) return ''
const d = new Date(ms)
const pad = (n: number) => String(n).padStart(2, '0')
return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`
}
/** 该侧是否存在于这个条目(不存在的一侧显示为「—」并把名字压暗)。 */
function existsOn(entry: DirDiffEntry, side: DiffSide): boolean {
return side === 'a' ? !!entry.leftPath : !!entry.rightPath
}
function sizeOn(entry: DirDiffEntry, side: DiffSide): number {
return side === 'a' ? entry.leftSize : entry.rightSize
}
function timeOn(entry: DirDiffEntry, side: DiffSide): number {
return side === 'a' ? entry.leftModified : entry.rightModified
}
/** 状态点颜色(两侧都用同一套语义,便于一眼对上)。 */
function dotClass(status: DirDiffEntry['status']): string {
switch (status) {
case 'different':
return 'bg-danger'
case 'left-only':
return 'bg-warning'
case 'right-only':
return 'bg-info'
case 'type-mismatch':
return 'bg-danger'
default:
return 'bg-fg-disabled'
}
}
/** 行点击:目录折叠,文件开新选项卡(任一侧都可点)。 */
function onRowClick(node: TreeNode): void {
if (node.isDir) {
toggleDir(node.relPath)
return
}
const entry = node.entry
if (!entry) return
emit('open-file', { side: existsOn(entry, 'a') ? 'a' : 'b', entry })
}
/**
* 文件名颜色:**有差异**的文件用红、一致的文件用前景色(浅色主题下即黑色);
* 该侧不存在时一律压暗(那是「—」占位,不该与真实名字同色调)。
*
* 目录保持前景色:目录的差异由前面的状态点与另一侧的「—」表达,把整棵树的目录都染红
* 反而让真正要看的那几个文件淹没在噪声里。
*/
function nameClass(node: TreeNode, side: DiffSide): string {
if (!node.entry || !existsOn(node.entry, side)) return 'text-fg-disabled'
if (node.isDir) return 'text-foreground'
return node.entry.status === 'identical' ? 'text-foreground' : 'text-danger-text'
}
/**
* 该条目的「不同」是**按时间戳**判定的,而非内容逐字节比对。
*
* 后端只在「大小相同、时间戳不同」时才读内容核对,且有预算(单文件体积 / 条数上限);
* 预算用尽或文件过大时结论仍记为 `different`,但 `contentCompared` 为 false —— 界面上
* 必须与「已确认不同」区分,否则等于把猜测当结论。
*
* 判据要连 `leftSize === rightSize` 一起看:**大小不同**时后端也把 `contentCompared`
* 记为 false(它根本不需要读内容 —— 大小都不同,内容不可能相同),那是确定结论,
* 拿 `!contentCompared` 单独当判据会给几乎每个差异文件都挂上「未核实」。
*/
function unverified(entry: DirDiffEntry | null): boolean {
return (
!!entry &&
entry.status === 'different' &&
!entry.contentCompared &&
entry.leftSize === entry.rightSize
)
}
/**
* 目录行是否隐藏「大小 / 已修改」两列(合并成一个占位)。
*
* 目录的这两个属性不是可用于对比的信号:大小(`meta.len()` 在 Windows 上取决于文件系统,
* 后端已统一置 0)没有意义;mtime 只是「有子项被增删改」的副产物,几乎每次都和另一侧不同,
* 拿它当差异线索会误导。因此目录行把这两列并成一格。
*
* 例外是 `type-mismatch`(同名但一侧是文件):那是有意义的差异,按原来的两列渲染。
*/
function quietMeta(node: TreeNode): boolean {
return node.isDir && node.entry?.status !== 'type-mismatch'
}
// ===== 左右两棵树滚动联动 =====
//
// 两侧渲染的是**同一份行**(行数、顺序完全一致,只有单元格内容不同),因此行高一致、
// 内容高度一致 —— 一个像素级的镜像就够了。
//
// 不用「布尔锁 + 延迟释放」那种写法:scroll 事件是异步派发的,锁的释放时机很难对齐,
// 漏放会让联动卡死、错放会让两侧互相推着抖动。这里改成**比较目标位置**:谁在滚动就把
// 另一侧对齐到同一位置;后者随后触发的 scroll 事件会发现「对方已经和我一样」,自然不再
// 回推 —— 无需在两次事件之间维护任何时序状态。
const treeRootRef = ref<HTMLElement | null>(null)
let viewports: [HTMLElement, HTMLElement] | null = null
/** 把 `to` 对齐到 `from`;差值 ≤1px 视为已对齐(避免像素取整引起的抖动)。 */
function mirrorScroll(from: HTMLElement, to: HTMLElement): void {
if (Math.abs(to.scrollTop - from.scrollTop) <= 1) return
to.scrollTop = from.scrollTop
}
// ===== 行虚拟化 =====
//
// 上限 8000 条 × 两侧 = 最多约 6 万个 DOM 节点,一次性铺出来会让首次渲染与滚动都卡。
// 这里只渲染视口内的行(上下各留 OVERSCAN 行),用上下两个撑高的空 div 占住剩余空间,
// 于是滚动条长度与滚动位置与「全部渲染」完全一致(两者之和恒等于 行数 × 行高)。
//
// 两侧**共用同一份窗口**:滚动已被联动对齐、行数又完全一致,因此一个 scrollTop 对
// 两边都成立 —— 不需要按侧各算一份(那还会引入两侧窗口错位的一类新 bug)。
/**
* 行高(px)。
*
* 必须与模板里行的高度严格相等(那里同一个 `:style` 里就写了 `height`)。用像素而不是
* `h-6.5` 这类 rem 类:虚拟化的偏移量必须精确等于真实行高,绑在显式常量上比「依赖根字号
* 恰好 16px(6.5 × 0.25rem = 26px)」可靠。
*/
const ROW_HEIGHT = 26
/** 视口上下各多渲染的行数(滚动时不至于露白)。 */
const OVERSCAN = 8
/** 两侧共用的滚动位置(联动使两侧恒等,虚拟化只需一份)。 */
const scrollTop = ref(0)
/** 视口高度(两侧等宽等高,取其中一个即可)。 */
const viewportHeight = ref(0)
let viewportObserver: ResizeObserver | null = null
/** 当前要渲染的行区间 `[first, last)`。 */
const rowRange = computed(() => {
const total = rows.value.length
const first = Math.max(0, Math.floor(scrollTop.value / ROW_HEIGHT) - OVERSCAN)
const last = Math.max(
first,
Math.min(total, Math.ceil((scrollTop.value + viewportHeight.value) / ROW_HEIGHT) + OVERSCAN)
)
return { first, last }
})
/** 视口内(含上下缓冲)的行,并带上它在**全量 rows** 里的下标(键盘导航与 ARIA 要用真下标)。 */
const visibleRows = computed(() =>
rows.value
.slice(rowRange.value.first, rowRange.value.last)
.map((row, i) => ({ row, index: rowRange.value.first + i }))
)
/** 可见行上方的占位高度。 */
const padTop = computed(() => rowRange.value.first * ROW_HEIGHT)
/** 可见行下方的占位高度。 */
const padBottom = computed(() =>
Math.max(0, (rows.value.length - rowRange.value.last) * ROW_HEIGHT)
)
// ===== 整行 hover =====
//
// 两侧渲染的是同一份行,却是**两个独立的滚动容器** —— 只在鼠标所在的那一侧加 CSS `hover:`
// 会让高亮只覆盖半行。这里改记一个**行下标**,两侧按同一个下标上色,看起来就是一整行。
//
// 用「指针位置 → 下标」而不是逐行 mouseenter:行是虚拟化的,滚动时同一个 DOM 节点会被
// 复用成别的行,靠 enter/leave 记下的「上一行」会失效(高亮停在错误的行上)。这里在滚动
// 时也用最后记录的指针 Y 重算一次,于是滚轮滚动时高亮依然跟得上。
/** 鼠标所在行的下标(-1 = 不在任何行上)。 */
const hoverIndex = ref(-1)
/** 最后一次指针的 clientY(NaN = 指针不在树上)。 */
let pointerClientY = Number.NaN
function updateHover(): void {
const viewport = viewports?.[0]
if (!viewport || Number.isNaN(pointerClientY)) {
hoverIndex.value = -1
return
}
// 两侧视口处于同一水平线、行高也一致,所以一个下标对两边都成立
const y = pointerClientY - viewport.getBoundingClientRect().top
if (y < 0 || y >= viewport.clientHeight) {
hoverIndex.value = -1
return
}
const index = Math.floor((y + scrollTop.value) / ROW_HEIGHT)
hoverIndex.value = index >= 0 && index < rows.value.length ? index : -1
}
function onTreeMouseMove(event: MouseEvent): void {
pointerClientY = event.clientY
updateHover()
}
function onTreeMouseLeave(): void {
pointerClientY = Number.NaN
hoverIndex.value = -1
}
const onLeftScroll = (): void => {
if (!viewports) return
scrollTop.value = viewports[0].scrollTop
mirrorScroll(viewports[0], viewports[1])
updateHover()
}
const onRightScroll = (): void => {
if (!viewports) return
scrollTop.value = viewports[1].scrollTop
mirrorScroll(viewports[1], viewports[0])
updateHover()
}
// 滚动的真实容器是 reka-ui 的 viewport(`.cm-*` 那套同理,原生滚动被它接管)。
// 两侧的 ScrollArea 始终渲染(空态 / 扫描中也一样),因此挂载后即可取到,无需等数据。
onMounted(async () => {
// 扫描进度是**全局**事件(Rust 不区分选项卡):按 scanSeq 过滤,只认本轮扫描的进度。
// 注册失败不该影响其余初始化(虚拟化与滚动联动才是主体)—— 进度只是锦上添花。
try {
unlistenProgress = await listen<DiffScanProgress>(EVENTS.diffScanProgress, event => {
if (event.payload.scanId !== scanSeq) return
scanProgress.value = event.payload
})
} catch {
/* 注册失败就静默降级为「扫描中…」,不影响扫描本身 */
}
const found = treeRootRef.value?.querySelectorAll<HTMLElement>('[data-reka-scroll-area-viewport]')
if (!found || found.length < 2) return
const left = found[0]
const right = found[1]
if (!left || !right) return
viewports = [left, right]
left.addEventListener('scroll', onLeftScroll, { passive: true })
right.addEventListener('scroll', onRightScroll, { passive: true })
// 视口高度是虚拟化的另一个输入:它随窗口尺寸 / 分栏变化,用 ResizeObserver 跟住
viewportHeight.value = left.clientHeight
viewportObserver = new ResizeObserver(() => {
viewportHeight.value = viewports?.[0]?.clientHeight ?? 0
})
viewportObserver.observe(left)
})
onBeforeUnmount(() => {
viewports?.[0].removeEventListener('scroll', onLeftScroll)
viewports?.[1].removeEventListener('scroll', onRightScroll)
viewports = null
viewportObserver?.disconnect()
viewportObserver = null
unlistenProgress?.()
unlistenProgress = null
})
/**
* 换过滤条件 / 重新扫描后两侧回到顶部。
*
* 不复位的话,原来滚到很靠下时新内容可能停在中间甚至底部,用户会以为「结果没变」。
* 两侧一起设 0(而不是走镜像):此处语义就是「从头看」,显式置顶比镜像更直白。
*/
watch([() => session.value.filter, () => session.value.report], () => {
scrollTop.value = 0
if (!viewports) return
viewports[0].scrollTop = 0
viewports[1].scrollTop = 0
})
// ===== 键盘可达性 =====
//
// 行是 div,本身不可聚焦 —— 键盘用户完全用不了。这里按 ARIA tree 的常规做法补上:
// 行 `role="treeitem"`(带 aria-level / aria-expanded / aria-selected),并用
// **roving tabindex**(同一时刻只有一个行可 Tab 到)避免 Tab 要穿过上千行;方向键在
// `rows` 上移动,Enter / 空格与鼠标点击同义。
//
// 与虚拟化的配合:目标行在窗口外时先把它滚进视口、等这一帧渲染完再 `focus` ——
// 否则要聚焦的元素在虚拟化下根本不在 DOM 里。
/** 当前键盘活动行。存 **relPath** 而不是下标:过滤 / 折叠 / 重新扫描都会让下标失效。 */
const activeRelPath = ref('')
/** 活动行在 `rows` 里的下标;存的路径已不在当前行集里时回落到第一行。 */
const activeRowIndex = computed(() => {
const index = rows.value.findIndex(row => row.node.relPath === activeRelPath.value)
return index >= 0 ? index : 0
})
function isActive(index: number): boolean {
return index === activeRowIndex.value
}
/** 直接设置两侧的滚动位置(键盘导航用;两侧联动会随之对齐)。 */
function scrollBoth(top: number): void {
scrollTop.value = top
if (!viewports) return
viewports[0].scrollTop = top
viewports[1].scrollTop = top
}
/** 让第 index 行进入视口(必要时滚动)。 */
function revealIndex(index: number): void {
const top = index * ROW_HEIGHT
const bottom = top + ROW_HEIGHT
if (top < scrollTop.value) scrollBoth(top)
else if (bottom > scrollTop.value + viewportHeight.value) {
scrollBoth(bottom - viewportHeight.value)
}
}
/** 移动活动行,并按需滚动 + 聚焦。 */
function moveActive(index: number): void {
const total = rows.value.length
if (!total) return
const clamped = Math.max(0, Math.min(index, total - 1))
const row = rows.value[clamped]
if (!row) return
activeRelPath.value = row.node.relPath
revealIndex(clamped)
void nextTick(() => {
treeRootRef.value?.querySelector<HTMLElement>('[data-active-row]')?.focus()
})
}
/** 第 index 行的最近祖先(`rows` 是深度优先展平,往前找第一个深度更小的行)。 */
function parentIndexOf(index: number): number {
const depth = rows.value[index]?.depth ?? 0
for (let i = index - 1; i >= 0; i--) {
if ((rows.value[i]?.depth ?? 0) < depth) return i
}
return -1
}
/** 点击 / Tab 到某一行时把它记为活动行(roving tabindex 的锚点)。 */
function onRowFocus(node: TreeNode): void {
activeRelPath.value = node.relPath
}
function onTreeKeydown(event: KeyboardEvent): void {
const total = rows.value.length
if (!total) return
const index = activeRowIndex.value
const row = rows.value[index]
if (!row) return
switch (event.key) {
case 'ArrowDown':
event.preventDefault()
moveActive(index + 1)
break
case 'ArrowUp':
event.preventDefault()
moveActive(index - 1)
break
case 'ArrowRight':
event.preventDefault()
// 折叠的目录先展开;否则移动到下一行(若下一行是子项,那正是「第一个子项」)
if (row.node.isDir && session.value.collapsed.has(row.node.relPath)) {
toggleDir(row.node.relPath)
} else {
moveActive(index + 1)
}
break
case 'ArrowLeft':
event.preventDefault()
// 展开的目录先折叠;否则回到父目录
if (row.node.isDir && !session.value.collapsed.has(row.node.relPath)) {
toggleDir(row.node.relPath)
} else {
const parent = parentIndexOf(index)
if (parent >= 0) moveActive(parent)
}
break
case 'Home':
event.preventDefault()
moveActive(0)
break
case 'End':
event.preventDefault()
moveActive(total - 1)
break
case 'Enter':
case ' ':
event.preventDefault()
onRowClick(row.node)
break
default:
break
}
}
defineExpose({ compare, setRoot, loadDropped })
</script>
<template>
<!-- 整块铺不透明底色:窗根是透明窗(mica/acrylic),不给底色的话「路径输入行 + 文件树」
会透出窗口背景,与旁边面板的观感割裂 -->
<div class="flex min-h-0 flex-1 flex-col bg-background">
<!-- 控制行:扫描 + 过滤 + 两个开关 -->
<div class="flex h-8 shrink-0 items-center gap-1 border-b border-border px-2">
<Button size="sm" class="h-6" :disabled="!ready || session.scanning" @click="compare">
<Loader2 v-if="session.scanning" class="size-3.5 animate-spin" />
<RefreshCw v-else class="size-3.5" />
扫描
</Button>
<div class="mx-1 h-4 w-px shrink-0 bg-border" />
<Button
v-for="item in FILTERS"
:key="item.id"
variant="ghost"
size="sm"
class="h-6 px-2 text-[11px]"
:class="
session.filter === item.id
? 'bg-primary-soft font-medium text-primary-soft-text'
: 'text-fg-secondary hover:text-foreground'
"
@click="session.filter = item.id"
>
{{ item.label }}
</Button>
<div class="ml-auto flex shrink-0 items-center gap-1">
<Button variant="ghost" size="sm" class="h-6 px-2 text-[11px]" @click="setAllCollapsed(false)">
展开全部
</Button>
<Button variant="ghost" size="sm" class="h-6 px-2 text-[11px]" @click="setAllCollapsed(true)">
折叠全部
</Button>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[11px] transition-colors"
:class="
session.skipBuild
? 'bg-primary-soft font-medium text-primary-soft-text'
: 'text-fg-secondary hover:bg-hover'
"
title="跳过 node_modules / .git / target 等常见构建目录"
@click="session.skipBuild = !session.skipBuild"
>
跳过构建目录
</button>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[11px] transition-colors"
:class="
session.compareContent
? 'bg-primary-soft font-medium text-primary-soft-text'
: 'text-fg-secondary hover:bg-hover'
"
title="大小相同、时间戳不同时读内容逐字节比对(更准,也更慢)"
@click="session.compareContent = !session.compareContent"
>
比对内容
</button>
</div>
</div>
<!-- 左右两棵结构树(滚动联动,见脚本里的滚动镜像;方向键导航的 keydown 挂在这层容器上,
事件从聚焦的行冒泡上来 —— 两侧共用一套导航) -->
<div
ref="treeRootRef"
class="flex min-h-0 flex-1"
@keydown="onTreeKeydown"
@mousemove="onTreeMouseMove"
@mouseleave="onTreeMouseLeave"
>
<div
v-for="side in SIDES"
:key="side"
class="flex min-w-0 flex-1 flex-col"
:class="side === 'b' ? 'border-l border-border' : ''"
>
<!-- 该侧的根路径:可自由输入,也可用图标按钮选 -->
<div class="flex h-8 shrink-0 items-center gap-1 border-b border-border px-1.5">
<Input
:model-value="rootOf(side)"
class="h-6 flex-1 font-mono text-[11px]"
:placeholder="side === 'a' ? '左侧文件夹…' : '右侧文件夹…'"
spellcheck="false"
@change="(e: Event) => onRootInput(side, e)"
@keydown.enter="onRootEnter(side, $event)"
/>
<Button variant="ghost" size="icon-sm" title="选择文件夹" @click="browse(side)">
<FolderOpen class="size-3.5" />
</Button>
</div>
<!-- 列头(名称 / 大小 / 已修改,与 Beyond Compare 的口径一致) -->
<div
class="flex h-6 shrink-0 items-center gap-2 border-b border-divider px-2 text-[10px] text-muted-foreground"
>
<span class="min-w-0 flex-1">名称</span>
<span class="w-16 shrink-0 text-right">大小</span>
<span class="w-24 shrink-0 text-right">已修改</span>
</div>
<ScrollArea class="min-h-0 flex-1">
<div v-if="!session.report && !session.scanning" class="p-3">
<StateBlock
variant="empty"
title="选择左右两个文件夹开始对比"
description="两侧都可以直接输入路径或点文件夹图标选择;也可以把文件夹拖到这一侧"
:min-height="160"
/>
</div>
<div
v-else-if="session.scanning"
class="flex items-center gap-2 p-3 text-xs text-muted-foreground"
>
<Loader2 class="size-3.5 animate-spin" />{{ progressText ?? '正在扫描…' }}
</div>
<div v-else-if="!rows.length" class="p-3">
<StateBlock
variant="empty"
:title="session.filter === 'diff' ? '两棵目录树没有差异' : '当前过滤条件下没有条目'"
description="换一个过滤条件,或点「全部」查看两侧所有的文件"
:min-height="140"
/>
</div>
<!-- 行虚拟化:上下两个占位 div 撑住未渲染的部分(见脚本里的「行虚拟化」)。
这层也是该侧的 ARIA tree —— 左右各一棵(两侧展示的是同一批行的不同侧信息) -->
<div v-else role="tree" :aria-label="side === 'a' ? '左侧目录' : '右侧目录'">
<div :style="{ height: `${padTop}px` }" aria-hidden="true" />
<div
v-for="item in visibleRows"
:key="item.row.node.relPath"
role="treeitem"
:aria-level="item.row.depth + 1"
:aria-expanded="
item.row.node.isDir ? !session.collapsed.has(item.row.node.relPath) : undefined
"
:aria-selected="isActive(item.index)"
:tabindex="isActive(item.index) ? 0 : -1"
:data-active-row="isActive(item.index) ? '' : undefined"
class="flex cursor-pointer items-center gap-2 pr-2 text-xs focus:outline-none"
:class="
item.index === hoverIndex ? 'bg-hover' : isActive(item.index) && 'bg-row-selected'
"
:style="{ height: `${ROW_HEIGHT}px`, paddingLeft: `${4 + item.row.depth * 14}px` }"
@click="onRowClick(item.row.node)"
@focus="onRowFocus(item.row.node)"
>
<!-- 展开箭头(两侧共用折叠状态,点哪边都一样;键盘用 → / ← 展开折叠) -->
<button
v-if="item.row.node.isDir"
type="button"
tabindex="-1"
class="flex size-4 shrink-0 items-center justify-center text-muted-foreground"
@click.stop="toggleDir(item.row.node.relPath)"
>
<ChevronDown
v-if="!session.collapsed.has(item.row.node.relPath) && item.row.node.children.length"
class="size-3.5"
/>
<ChevronRight v-else-if="item.row.node.children.length" class="size-3.5" />
</button>
<span
v-else
class="ml-0.5 size-1.5 shrink-0 rounded-full"
:class="dotClass(item.row.node.entry?.status ?? 'identical')"
/>
<span
class="min-w-0 flex-1 truncate"
:class="[item.row.node.isDir ? 'font-medium' : '', nameClass(item.row.node, side)]"
>
{{ item.row.node.name }}
</span>
<!-- 「不同」是按时间戳判定的(大小相同、时间戳不同,但没读内容核对) —— 不能
与已确认的差异用同一种语气,故单独标出 -->
<span
v-if="unverified(item.row.node.entry)"
class="shrink-0 rounded-sm bg-warning-soft px-1 text-[9px] text-warning-text"
title="两侧大小相同但时间戳不同,且未读内容逐字节比对(文件过大或比对预算用尽)——这是按时间戳判定的差异,未必真的不同"
>
未核实
</span>
<!-- 目录行:大小 / 已修改不是对比信号,合并成一格(见脚本里的 quietMeta)。
宽度 = 4rem + gap(0.5rem) + 6rem,与下面两格的合计严格一致,名字列才不会错位 -->
<span
v-if="quietMeta(item.row.node)"
class="w-[10.5rem] shrink-0 text-right font-mono text-[10px] text-fg-disabled"
title="目录的大小与已修改时间不参与对比(大小在 Windows 上无意义,mtime 只是子项变动的副产物)"
>
—
</span>
<template v-else>
<span class="w-16 shrink-0 text-right font-mono text-[10px] text-muted-foreground">
{{ item.row.node.entry && existsOn(item.row.node.entry, side) && !item.row.node.isDir ? formatSize(sizeOn(item.row.node.entry, side)) : '—' }}
</span>
<span class="w-24 shrink-0 truncate text-right font-mono text-[10px] text-muted-foreground">
{{ item.row.node.entry && existsOn(item.row.node.entry, side) ? formatTime(timeOn(item.row.node.entry, side)) : '—' }}
</span>
</template>
</div>
<div :style="{ height: `${padBottom}px` }" aria-hidden="true" />
</div>
</ScrollArea>
</div>
</div>
<!-- 汇总 -->
<footer
class="flex h-7 shrink-0 items-center gap-3 border-t border-border px-3 text-[11px] text-muted-foreground"
>
<span v-if="session.report" class="tabular-nums text-danger-text">不同 {{ summary.different }}</span>
<span v-if="session.report" class="tabular-nums text-warning-text">仅左 {{ summary.leftOnly }}</span>
<span v-if="session.report" class="tabular-nums text-info-text">仅右 {{ summary.rightOnly }}</span>
<span v-if="session.report" class="tabular-nums">相同 {{ summary.identical }}</span>
<span v-if="summary.mismatch" class="tabular-nums text-danger-text">
类型不一致 {{ summary.mismatch }}
</span>
<span v-if="session.report?.skippedDirs" class="tabular-nums">
已跳过 {{ session.report.skippedDirs }} 个目录
</span>
<span class="truncate text-muted-foreground">点任意一侧的文件即可新开一个文件对比选项卡</span>
<span class="ml-auto shrink-0 tabular-nums">
<template v-if="session.scanning">{{ progressText ?? '扫描中…' }}</template>
<template v-else-if="session.report">
{{ session.report.entries.length }} 项 · {{ session.report.elapsedMs }} ms
</template>
</span>
<span v-if="session.report?.truncated" class="shrink-0 text-warning-text">
条目已达上限,结果被截断
</span>
</footer>
</div>
</template>
File diff suppressed because it is too large. Load diff
+64
View File
@@ -0,0 +1,64 @@
/**
* 对比模块的 IPC 客户端:命令名的**唯一落点**。
*
* 与 `editor/editorClient.ts` 同一理由:命令名与返回类型只在本文件出现一次,
* 避免散落在组件里各自手写(后端改字段时前端还会编译通过)。
*
* 参数名用 snake_case 形态的 camelCase(与 tauri-specta 的调用约定一致)。
*/
import { invoke } from '@tauri-apps/api/core'
import type { DiffFileDoc, DiffSettings, DirDiffReport } from './types'
export const diffClient = {
/**
* 读取一侧的文件(文本自动探测编码;二进制只回元信息)。
*
* 该命令同时登记「已授权可写」,因此随后可以直接 `writeFile` 保存。
*/
readFile: (path: string) => invoke<DiffFileDoc>('diff_read_file', { path }),
/**
* 把一侧的内容写回磁盘。
*
* `encoding` / `eol` 必须回传**读取时探测到的值**:否则一次保存就会把 GBK 文件
* 变成 UTF-8、CRLF 变成 LF,整个 diff 会因此掀翻。
*/
writeFile: (path: string, content: string, encoding: string, eol: string) =>
invoke<DiffFileDoc>('diff_write_file', { path, content, encoding, eol }),
/**
* 探测路径是文件还是目录(拖入与 `?path=` 时前端拿不到文件系统元信息)。
*
* 只读一次 `metadata`,不写盘、不需授权。
*/
pathKind: (path: string) => invoke<'dir' | 'file' | 'missing'>('diff_path_kind', { path }),
/**
* 对比两棵目录树(只读)。
*
* `skipDirs` 是**目录名**清单(大小写不敏感):默认清单由前端给出(它是界面约定,
* 用户能不能改是 UI 的事),后端只负责按它执行。
*
* `scanId` 由前端生成:后端把它原样放进进度事件(`diff-scan-progress`),前端据此
* 只认自己那一轮的进度 —— 事件是全局的,多个选项卡可能同时在扫。
*/
compareDirs: (
scanId: number,
left: string,
right: string,
skipDirs: string[],
compareContent: boolean
) =>
invoke<DirDiffReport>('diff_compare_dirs', { scanId, left, right, skipDirs, compareContent }),
// ===== 设置 =====
getSettings: () => invoke<DiffSettings>('diff_get_settings'),
/**
* 保存设置。
*
* Rust 侧保存后会**就地重注册**全局快捷键,因此「改了快捷键立刻生效」,
* 不需要前端再调一次注册命令。
*/
saveSettings: (settings: DiffSettings) =>
invoke<DiffSettings>('diff_save_settings', { settings })
}
+39
View File
@@ -0,0 +1,39 @@
import type { ModuleConfig } from '@/types/module'
import type { SearchIndexItem } from '@/stores/searchIndex'
/**
* 对比工具模块:文本 / 文件 / 文件夹三层对比。
*
* 规划见 `doc/DIFF_MODULE_PLAN.md`。当前进度 = **P1(文本对比)**:
* 双栏 MergeView 已可用;文件对比(P2)与文件夹对比(P3)待做。
*
* 为什么独立成模块而不是塞进编辑器:编辑器模块的中心对象是「一篇文档的生命周期」
* (标签 / 自动保存 / 光标 / 会话恢复),而对比工具是「两个只读视图 + 一棵目录树」,
* 没有自动保存、没有文档标签。混进去会让编辑器的窗口与 store 继续膨胀,也会让
* `editor-window-*` 这个 capability 的语义变模糊(详见规划 §5)。
*/
const searchItems: SearchIndexItem[] = [
{
title: '对比工具',
description: '文本 / 文件 / 文件夹对比:双栏差异视图,类 Beyond Compare',
keywords: ['对比', '比较', '差异', 'diff', 'compare', '文本对比', '文件对比', '文件夹对比', 'merge']
},
{
title: '打开对比窗口',
description: '打开对比工具窗口,粘贴两段文本或(P2 起)拖入文件开始比较',
keywords: ['打开', '对比', '窗口', '独立窗口', 'diff', 'compare']
}
]
export const moduleConfig: ModuleConfig = {
id: 'diff',
name: '对比工具',
icon: 'diff',
description: '文本 / 文件 / 文件夹对比(双栏差异视图;目录对比只读,不做写回)',
category: 'tool',
defaultEnabled: true,
loader: () => import('./DiffModule.vue'),
searchItems,
// 紧挨编辑器(45):两者同属「处理文本 / 文件」一族
order: 50
}
+84
View File
@@ -0,0 +1,84 @@
/**
* 对比窗口的创建入口(由前端创建,范式同 `editor/openWindow.ts`)。
*
* # 为什么是单例
*
* 与编辑器窗口(可多开、按目标判重)不同,对比工具的语义是「比较这一对目标」,
* 窗口里本来就同时容纳左右两侧 —— 多开只会让用户分不清哪一对是哪一对。
* 因此 label 固定为 `diff-window`,已存在就强制置前。
*
* # 隐藏创建 + 先应用主题
*
* 窗口初始底色是白的,而深色主题要等前端读 localStorage 后才应用 —— 直接显示会先
* 闪一下纯白。因此 `visible: false` 创建,由 `DiffWindow.vue` 应用完主题(含窗口效果)
* 与任务栏身份之后再自己 `show()`(同编辑器 / 终端窗口)。
*
* # 置前走原生命令
*
* `SetForegroundWindow` 不受 Windows 前台锁定限制;前端 `setFocus()` 在「本进程不拥有
* 前台」时会被系统直接忽略(表现为窗口明明开着却唤不到前面)。同下载窗口 / 快速面板。
*/
import { WebviewWindow } from '@tauri-apps/api/webviewWindow'
import { invoke } from '@tauri-apps/api/core'
import { createLogger } from '@/lib/logger'
import { WINDOWS } from '@/lib/constants'
const logger = createLogger('diff')
const LABEL = WINDOWS.diffWindow
/**
* 打开(或唤出)对比窗口。
*
* @param target 可选:P2 起用于把某个文件 / 文件夹作为初始目标(写入 URL 查询串)
*/
export async function openDiffWindow(target?: { path?: string }): Promise<void> {
const existing = await WebviewWindow.getByLabel(LABEL)
if (existing) {
try {
await invoke('window_focus_window', { label: LABEL })
return
} catch (e) {
logger.warn(`唤出既有对比窗口失败:${String(e)}`)
}
}
const query = target?.path ? `?path=${encodeURIComponent(target.path)}` : ''
const win = new WebviewWindow(LABEL, {
url: `index.html#${LABEL}${query}`,
title: '对比',
width: 1180,
height: 780,
minWidth: 720,
minHeight: 460,
resizable: true,
// 自绘标题栏(与编辑器 / 终端 / 文件窗口一致)
decorations: false,
// 透明通道用于承载 mica / acrylic
transparent: true,
shadow: true,
center: true,
visible: false,
focus: false,
// 拖入任意文件 / 文件夹作为某一侧目标(P2 起真正使用)
dragDropEnabled: true
})
// 不要等到 `tauri://created` 之后才挂错误监听:窗口创建过快时事件可能早于监听注册
win.once('tauri://error', e => logger.error(`打开对比窗口失败:${String(e)}`))
// 补注入拖放支持:wry 只在创建 webview 那一刻扫一次子窗口,运行期新建的窗口拿不到
// OLE drop target(拖文件进去是禁止光标)。详见 src-tauri/src/drag_drop.rs
//
// 注意**不要**放到下面那个 `await` 之后:`tauri://created` 在窗口创建过快时可能早于
// 监听注册而永远等不到。Rust 侧会自行重试等待窗口与 WebView2 子窗口就位,因此这里
// fire-and-forget 即可。
void invoke('window_attach_drag_drop', { label: LABEL }).catch(e => {
logger.warn(`拖放补注入失败:${String(e)}`)
})
await new Promise<void>((resolve, reject) => {
win.once('tauri://created', () => resolve())
win.once('tauri://error', e => reject(new Error(String(e))))
})
}
+157
View File
@@ -0,0 +1,157 @@
/**
* 对比模块的前端类型。
*
* [`DiffStats`] 由 `MergeView` 的 chunk 列表算出(纯前端);[`DiffFileDoc`] 与 Rust 侧
* `diff::types::DiffFileDoc` 一一对应(新增字段两侧都要改)。
*/
/** 两侧文本的差异统计(状态栏展示用)。 */
export interface DiffStats {
/** 变化块数量(MergeView 的 chunk 个数) */
chunks: number
/** 右侧相对左侧新增的行数 */
addedLines: number
/** 左侧相对右侧被删除的行数 */
removedLines: number
/** 左侧行数(空文档为 0,而不是 CM6 报的 1) */
linesA: number
/** 右侧行数(同左) */
linesB: number
}
/** 某一侧的文件状态(来自 `diff_read_file` / `diff_write_file`)。 */
export interface DiffFileDoc {
/** 绝对路径 */
path: string
/** 显示名(文件名) */
name: string
/** 文本内容(换行已统一为 `\n`)。二进制文件为空串 */
content: string
/** 探测到的编码(`utf-8` / `gbk` / …)。二进制文件为空串 */
encoding: string
/** 换行风格:"lf" | "crlf"。二进制文件为空串 */
eol: string
/** 文件字节数 */
size: number
/** 最后修改时间(Unix 毫秒) */
modified: number
/** 行数(二进制文件为 0) */
lines: number
/** 是否超过「大文件」阈值 */
large: boolean
/** 是否只读(写权限探测失败) */
readonly: boolean
/** 是否为二进制文件(不渲染 diff,只报「不同」) */
binary: boolean
}
/** 一侧的标识(左 = 原始,右 = 对比)。 */
export type DiffSide = 'a' | 'b'
/** 目录对比中一个条目的状态。 */
export type DirDiffStatus =
/** 仅左侧有 */
| 'left-only'
/** 仅右侧有 */
| 'right-only'
/** 两侧都有且内容不同 */
| 'different'
/** 两侧都有且相同 */
| 'identical'
/** 同名但一侧是文件、另一侧是目录 */
| 'type-mismatch'
/**
* 目录对比中的一个条目(扁平列表,由前端组装成树)。
*
* 与 Rust 侧 `diff::types::DirDiffEntry` 一一对应。
*/
export interface DirDiffEntry {
/** 相对根的路径,/ 分隔(显示名从前端最后一段取) */
relPath: string
/** 是否目录(`type-mismatch` 时视为目录) */
isDir: boolean
status: DirDiffStatus
/** 该侧绝对路径;该侧不存在时为空串 */
leftPath: string
rightPath: string
leftSize: number
rightSize: number
leftModified: number
rightModified: number
/**
* 结论是否由**内容逐字节比对**得出。
*
* `false` 表示「大小相同、时间戳不同」且未读内容(体积超限 / 预算用尽),
* 此时 `different` 是按时间戳判定的 —— 界面上要区别于已确认的差异。
*/
contentCompared: boolean
}
/** 目录对比的扫描进度(事件负载,与 Rust 侧 `diff::types::DiffScanProgress` 一一对应)。 */
export interface DiffScanProgress {
/** 本轮扫描的标识(前端生成、随命令传入,据此过滤掉其它选项卡的进度) */
scanId: number
/** `scan` = 正在遍历目录;`compare` = 正在读内容逐字节核对 */
phase: 'scan' | 'compare'
/** 已完成数(遍历 = 已过的条目数;核对 = 已比对的文件数) */
done: number
/** 总数(遍历阶段未知为 0;核对阶段为预算上限) */
total: number
}
/** 一次目录对比的结果。 */
export interface DirDiffReport {
leftRoot: string
rightRoot: string
entries: DirDiffEntry[]
/** 条目数达到上限、遍历被截断 */
truncated: boolean
/** 按跳过清单略过的目录数 */
skippedDirs: number
/** 扫描耗时(毫秒) */
elapsedMs: number
}
/** 目录对比的过滤条件。 */
export type DirFilterId = 'diff' | 'all' | 'left-only' | 'right-only'
/**
* 目录对比选项卡的状态。
*
* 由 `DiffWindow` 持有(它是选项卡会话的宿主),`DirDiffView` 读写它。
*
* # 为什么把可变会话对象当 prop 传,而不是逐项 props/emits
*
* 这里的状态有 8 个字段、且几乎每个都会双向改(输入根路径、切过滤、折叠、扫描结果…)。
* 逐项拆成 `v-model` + emitters 会得到十几个 props 与 emits,而它们**本来就是同一个
* 东西**(一个选项卡的会话状态)。因此按「共享可变模型」传:`DirDiffView` 直接改字段、
* 只把无法自己完成的动作(触发扫描)emit 出去。
*/
export interface DirSessionState {
leftRoot: string
rightRoot: string
report: DirDiffReport | null
scanning: boolean
filter: DirFilterId
/**
* 已折叠的目录相对路径。
*
* **两侧共用一份**:两个结构树渲染的是同一个并集树(行数与顺序完全一致,只有单元格
* 内容不同),共用折叠状态才不会让左右两边错行。
*/
collapsed: Set<string>
skipBuild: boolean
compareContent: boolean
}
/** 对比模块设置(与 Rust 侧 `diff::types::DiffSettings` 一一对应)。 */
export interface DiffSettings {
version: number
/** 全局快捷键:打开 / 唤出对比窗口(空串 = 不注册) */
openDiffShortcut: string
/** 目录对比:默认是否比对内容 */
compareContent: boolean
/** 目录对比:默认是否跳过常见构建目录 */
skipBuildDirs: boolean
}
@@ -1,6 +1,7 @@
<script setup lang="ts">
import { ref, computed, onMounted, onUnmounted } from 'vue'
import { getCurrentWindow, Effect, EffectState } from '@tauri-apps/api/window'
import { invoke } from '@tauri-apps/api/core'
import { LogicalSize } from '@tauri-apps/api/dpi'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
import { Pause, Play, X, Minus, FolderOpen, AlertCircle, Loader2, XCircle } from '@lucide/vue'
@@ -280,6 +281,12 @@ onMounted(async () => {
window.setTimeout(async () => {
// 隐藏态下多贴合一次,确保尺寸已对内容就位
await applyAutoHeight()
// 任务栏身份:窗口级 AUMID(独立任务栏按钮)+ 组合图标;必须在 show() 之前设置
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'download' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try { await win.show() } catch { /* 忽略 */ }
try { await win.unminimize() } catch { /* 忽略 */ }
void commands.downloaderFocusWindow(win.label).catch(() => {})
+6
View File
@@ -130,6 +130,12 @@ function closeWindow() {
onMounted(async () => {
await applyTheme()
// 任务栏身份:窗口级 AUMID(独立任务栏按钮)+ 组合图标;必须在 show() 之前设置
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'dsh' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try {
await win.show()
await win.setFocus()
+110 -12
View File
@@ -13,6 +13,8 @@
* - 空态一律 `StateBlock`,不手写占位文案
*/
import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { getCurrentWebview } from '@tauri-apps/api/webview'
import type { UnlistenFn } from '@tauri-apps/api/event'
import { open } from '@tauri-apps/plugin-dialog'
import { openPath } from '@tauri-apps/plugin-opener'
import {
@@ -48,6 +50,7 @@ import {
import { ConfirmDialog, SettingRow, StateBlock } from '@/components/common'
import { useModuleTabs } from '@/lib/use-module-tabs'
import { WINDOWS } from '@/lib/constants'
import { createLogger } from '@/lib/logger'
import { useEditorStore } from '@/stores/editorStore'
import { openEditorWindow } from './openWindow'
import { editorClient } from './editorClient'
@@ -58,6 +61,11 @@ import NewNoteDialog from './components/NewNoteDialog.vue'
import type { ContextMenuStatus, EditorSettings } from '@/types/editor'
const store = useEditorStore()
const logger = createLogger('editor')
/** 是否正有文件被拖到模块页上方(显示拖入提示遮罩) */
const dragOver = ref(false)
let unlistenDragDrop: UnlistenFn | null = null
const activeTab = ref('overview')
// Tab 结构(规划 §6.1):概览 / 库 / 编辑器 / 集成。
@@ -74,29 +82,98 @@ useModuleTabs(
{ alwaysVisible: true }
)
/**
* 模块页拖入文件:为每个路径开一个编辑器窗口(本页只做管理,编辑在独立窗口)。
*
* 用 Tauri 原生拖放事件(`onDragDropEvent`)而非 HTML5 `drop`:`dragDropEnabled`
* 默认开启时 Tauri 会接管 WebView2 的拖放,HTML5 在 Windows 上拿不到外部文件路径。
* 注意 Windows UIPI 会拦截拖入以管理员运行的窗口 —— 仅在非提权时可用。
*/
async function onDroppedPaths(paths: string[]): Promise<void> {
for (const path of paths) {
try {
const options = (await editorClient.pathKind(path)) === 'folder' ? { folder: path } : { path }
await openEditorWindow(options)
} catch (e) {
toast.error(`打开失败:${String(e)}`)
}
}
}
/** HTML5 dragover:亮遮罩(只有在 Tauri 原生拖放未接管时才会触发,见 onDomDrop)。 */
function onDomDragOver(): void {
dragOver.value = true
}
/**
* HTML5 `drop` 兜底:拦住浏览器默认行为(否则会把文件内容插进页面/编辑器),
* 能拿到绝对路径时照样打开。正常情况下拖放由 Tauri 原生处理器接管,这里不会被触发。
*/
function onDomDrop(event: DragEvent): void {
event.preventDefault()
dragOver.value = false
const files = Array.from(event.dataTransfer?.files ?? [])
const paths = files
.map(f => (f as File & { path?: string }).path)
.filter((p): p is string => !!p)
if (paths.length) {
void onDroppedPaths(paths)
} else if (files.length) {
logger.warn(`拖放未走原生通道(files=${files.length},取不到绝对路径)`)
toast.error('未取到拖入文件的绝对路径(拖放被浏览器接管),请改用「打开文件」')
}
}
onMounted(() => {
// 快捷键在别的模块按下时 App.vue 已把请求挂起并切到本页:挂载即消费
if (store.consumeNewNote()) openNewNote()
void store.init()
void loadContextMenu()
const selfWebview = getCurrentWebview()
void selfWebview
.onDragDropEvent(event => {
const payload = event.payload
if (payload.type === 'enter' || payload.type === 'over') {
dragOver.value = true
} else if (payload.type === 'drop') {
dragOver.value = false
logger.info(`原生拖放 drop:${payload.paths.length} 项`)
void onDroppedPaths(payload.paths)
} else {
dragOver.value = false
}
})
.then(unlisten => {
unlistenDragDrop = unlisten
})
logger.info(`拖放监听已注册:webview=${selfWebview.label}`)
})
onBeforeUnmount(() => {
unlistenDragDrop?.()
unlistenDragDrop = null
store.disposeListeners()
})
// ===== 全局快捷键请求(Rust 只发事件,这里负责开对话框 / 开窗口)=====
// ===== 全局快捷键请求(Rust 只发事件,App.vue 在应用级转发 / 开窗)=====
//
// 「新建笔记」:App.vue 收到快捷键后置挂起标记并切到本页,本页**挂载时消费**(快捷键在
// 其它模块按下时本页还没挂载,页内 watch 会漏掉),已挂载时则由下面的 watch 消费。
const newNoteOpen = ref(false)
function openNewNote(): void {
activeTab.value = 'overview'
newNoteOpen.value = true
}
watch(
() => store.newNoteRequest,
() => {
activeTab.value = 'overview'
newNoteOpen.value = true
() => store.newNotePending,
pending => {
if (pending && store.consumeNewNote()) openNewNote()
}
)
watch(
() => store.openEditorRequest,
() => void openEditor()
)
// 全局快捷键(`Alt+E` 打开编辑器窗口)由 App.vue 在应用级处理(快捷键在任意模块下
// 都要可用,不能依赖本页已挂载 —— 见 App.vue 的说明);这里只保留模块内的入口按钮。
/**
* 冷启动的「用 Thing 打开」:命令行留下的文件路径取到后,直接开一个笔记窗口。
@@ -304,7 +381,12 @@ const indexSummary = computed(() => {
</script>
<template>
<div class="min-h-full p-5">
<div
class="relative min-h-full p-5"
@dragenter.prevent="onDomDragOver"
@dragover.prevent="onDomDragOver"
@drop.prevent="onDomDrop"
>
<Tabs v-model="activeTab" class="flex min-h-full w-full flex-col">
<!-- ===== 概览 ===== -->
<TabsContent value="overview" class="tab-animate">
@@ -564,7 +646,7 @@ const indexSummary = computed(() => {
</CardHeader>
<CardContent class="!px-4">
<div class="flex flex-col divide-y divide-divider">
<SettingRow label="配色方案" description="跟随应用时按应用深浅自动选深/浅变体" control-width="wide">
<SettingRow label="配色方案" description="「跟随主应用主题」关闭时,窗口按本方案取色与深浅" control-width="wide">
<Select
:model-value="String(store.settings.editorTheme)"
@update:model-value="v => commit({ editorTheme: String(v) })"
@@ -578,7 +660,7 @@ const indexSummary = computed(() => {
</Select>
</SettingRow>
<SettingRow label="跟随应用深浅" description="开关打开时,配色方案仅作为取色基准">
<SettingRow label="跟随主应用主题" description="打开时编辑器窗口整体跟随主应用主题;关闭时由上方「配色方案」决定,窗口内外深浅一致">
<Switch
:model-value="store.settings.followAppTheme"
@update:model-value="v => commit({ followAppTheme: v === true })"
@@ -888,5 +970,21 @@ const indexSummary = computed(() => {
<!-- 全局快捷键(Ctrl+Shift+N)触发的新建对话框:落在库根 -->
<NewNoteDialog v-model:open="newNoteOpen" dir-rel="" />
<!-- 拖入提示遮罩(Tauri 原生拖放事件驱动) -->
<div
v-if="dragOver"
class="pointer-events-none absolute inset-0 z-50 flex items-center justify-center bg-background/70 backdrop-blur-sm"
>
<div
class="flex flex-col items-center gap-1.5 rounded-lg border-2 border-dashed border-primary px-8 py-6 text-center"
>
<NotebookPen class="size-6 text-primary" />
<span class="text-sm font-medium">松开以打开</span>
<span class="text-xs text-muted-foreground">
文件 / 文件夹会在新的编辑器窗口打开
</span>
</div>
</div>
</div>
</template>
+709 -40
View File
@@ -25,11 +25,27 @@
*/
import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { Effect, EffectState, getCurrentWindow } from '@tauri-apps/api/window'
import { invoke } from '@tauri-apps/api/core'
import { getCurrentWebview } from '@tauri-apps/api/webview'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
import { open, save } from '@tauri-apps/plugin-dialog'
import { AlertTriangle, History, Minus, NotebookPen, PanelLeft, Square, X } from '@lucide/vue'
import {
AlertTriangle,
FileCode2,
FileText,
History,
Loader2,
Minus,
NotebookPen,
PanelLeft,
Settings,
Square,
X
} from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Toaster } from '@/components/ui/sonner'
import { Button } from '@/components/ui/button'
import { ScrollArea } from '@/components/ui/scroll-area'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
import {
Dialog,
@@ -47,11 +63,13 @@ import {
DropdownMenuTrigger
} from '@/components/ui/dropdown-menu'
import { ConfirmDialog, StateBlock } from '@/components/common'
import { STORAGE_KEYS } from '@/lib/constants'
import { EVENTS, STORAGE_KEYS } from '@/lib/constants'
import { applyStoredAccent } from '@/lib/theme'
import { createLogger } from '@/lib/logger'
import { useEditorStore } from '@/stores/editorStore'
import type { PathReplaceResult } from '@/types/editor'
import { editorClient } from './editorClient'
import { EDITOR_THEMES } from './editor/themes'
import type { EditorOpenTabPayload, PathReplaceResult } from '@/types/editor'
import LibrarySidebar from './components/LibrarySidebar.vue'
import EditorHost from './components/EditorHost.vue'
import EditorToolbar from './components/EditorToolbar.vue'
@@ -60,6 +78,7 @@ import DrawerPanel from './components/DrawerPanel.vue'
import EditorTabs from './components/EditorTabs.vue'
import EditorSearch, { type SearchScope } from './components/EditorSearch.vue'
import SearchResultsPanel from './components/SearchResultsPanel.vue'
import EditorSettingsDialog from './components/EditorSettingsDialog.vue'
import { useEditorSearchStore } from '@/stores/editorSearchStore'
import type { Command, EditorView } from '@codemirror/view'
@@ -70,10 +89,18 @@ const searchStore = useEditorSearchStore()
const isDark = ref(false)
const sidebarVisible = ref(true)
/** 是否正有文件被拖到窗口上方(显示拖入提示遮罩) */
const dragOver = ref(false)
let unlistenDragDrop: UnlistenFn | null = null
/** 主窗口发来的「在既有窗口加标签」监听(见 openWindow.ts) */
let unlistenOpenTab: UnlistenFn | null = null
const hostRef = ref<InstanceType<typeof EditorHost> | null>(null)
const sidebarRef = ref<InstanceType<typeof LibrarySidebar> | null>(null)
const quickOpen = ref(false)
/** 设置对话框(库设置 / 编辑器设置,见 EditorSettingsDialog) */
const settingsOpen = ref(false)
const cursorColumn = ref(1)
const searchRef = ref<InstanceType<typeof EditorSearch> | null>(null)
// ===== 统一搜索器(P4-6):一个输入区覆盖「当前文件 / 当前目录 / 笔记库」 =====
const searchOpen = ref(false)
const searchScope = ref<SearchScope>('file')
@@ -81,6 +108,8 @@ const searchScope = ref<SearchScope>('file')
const drawerMode = ref<'outline' | 'links' | 'graph' | null>(null)
// ===== 主题与窗口效果(与主应用同步) =====
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
function readMainTheme(): { theme: string; effect: string } {
try {
const raw = localStorage.getItem(STORAGE_KEYS.appSettings)
@@ -100,17 +129,44 @@ function resolveIsDark(theme: string): boolean {
return window.matchMedia('(prefers-color-scheme: dark)').matches
}
/**
* 编辑器窗口当前应当采用的深浅(着色由它统一推导:外壳、mica 底色、编辑区)。
*
* - **跟随主应用主题**(设置开关打开):整体跟随应用 —— 读主应用写在同一份
* `localStorage` 里的主题;
* - **不跟随**(默认):由**配色方案**决定 —— 具体主题看它自身的亮暗归属,
* 配色方案为「跟随系统」时按应用解析出的系统深浅(应用本身为「跟随系统」即操作系统)。
*
* 这样窗口外壳(标题栏 / 侧栏 / 状态栏)与编辑区始终同深同浅,「内外统一」。
*/
function windowIsDark(): boolean {
// 应用的深浅(应用为「跟随系统」时按系统偏好解析)
const appDark = resolveIsDark(readMainTheme().theme)
if (store.settings.followAppTheme) return appDark
const theme = String(store.settings.editorTheme)
if (theme === 'system') return appDark
// 具体主题取自身的亮暗归属;未知取值回落到 vscode-dark(与 effectiveThemeName 一致,
// 避免外壳与编辑区深浅对不上)
return EDITOR_THEMES[theme]?.dark ?? EDITOR_THEMES['vscode-dark']?.dark ?? true
}
async function applyTheme(): Promise<void> {
const root = document.documentElement
const { theme, effect } = readMainTheme()
const { theme: appTheme, effect } = readMainTheme()
const dark = windowIsDark()
try {
await win.setTheme(theme === 'system' ? null : (theme as 'dark' | 'light'))
// 原生窗口主题**只跟应用主题走**,与其它独立窗口(终端 / 托盘 / 快速面板…)一致。
//
// ⚠️ 绝不能按编辑器自己的配色方案传 'dark'/'light':`setTheme` 会改写**整个应用**的
// `prefers-color-scheme`(同 appStore 的注释),于是托盘菜单、快速面板等靠
// `matchMedia` 取深浅的窗口会被编辑器一起带偏(表现为它们的文字与底色反了)。
// 编辑器自身的深浅由下面的 CSS class 决定,不依赖这里的原生主题。
await win.setTheme(appTheme === 'system' ? null : (appTheme as 'dark' | 'light'))
} catch {
/* 平台不支持时忽略 */
}
const dark = resolveIsDark(theme)
isDark.value = dark
root.classList.remove('dark', 'effect-mica', 'effect-acrylic', 'effect-normal')
root.classList.add(`effect-${effect}`)
@@ -120,8 +176,12 @@ async function applyTheme(): Promise<void> {
try {
// setEffects 会直接覆盖当前效果,无需 clearEffects(那个命令未在 capability 中授权)
if (effect === 'mica') {
// 用 micaDark / micaLight 明确指定着色:编辑器窗口的深浅可以与应用 / 系统不同
// (不跟随时由配色方案决定),沿用 `Effect.Mica` 会跟随系统深浅,深色编辑器配
// 浅色糊化层会「内深外浅」。同 appStore 的做法。
const micaEffect = (dark ? 'micaDark' : 'micaLight') as unknown as Effect
await win.setEffects({
effects: [Effect.Mica],
effects: [micaEffect],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
@@ -145,12 +205,17 @@ async function applyTheme(): Promise<void> {
}
}
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
const onThemeChange = () => void applyTheme()
const onStorageChange = (e: StorageEvent) => {
if (e.key === STORAGE_KEYS.appSettings) void applyTheme()
}
// 设置里改了「跟随主应用主题」或「配色方案」:窗口整体重新着色(外壳 + 编辑区)。
// 用逐项 watch 而不是 `() => [a, b]`:后者每次都会生成新数组,设置一刷新就误触发。
watch([() => store.settings.followAppTheme, () => String(store.settings.editorTheme)], () =>
void applyTheme()
)
// ===== 窗口控制 =====
const doMinimize = () => win.minimize().catch(() => undefined)
const doToggleMaximize = () => win.toggleMaximize().catch(() => undefined)
@@ -182,6 +247,60 @@ function requestCloseTab(id: string): void {
store.closeTab(id)
}
// ===== 标签栏右键菜单:批量关闭 =====
//
// 单标签关闭有「保存 / 放弃」三选一(见 requestCloseTab);批量关多个时逐个三选一
// 会把用户淹没,因此退化为**一次确认**:有脏数据 / 临时草稿就提示「会丢失改动」,
// 确认后统一放弃关闭。
/** 除指定标签外的全部 id。 */
function tabIdsExcept(id: string): string[] {
return store.tabs.filter(t => t.id !== id).map(t => t.id)
}
/** 指定标签左侧的全部 id。 */
function tabIdsLeftOf(id: string): string[] {
const index = store.tabs.findIndex(t => t.id === id)
return index < 0 ? [] : store.tabs.slice(0, index).map(t => t.id)
}
/** 指定标签右侧的全部 id。 */
function tabIdsRightOf(id: string): string[] {
const index = store.tabs.findIndex(t => t.id === id)
return index < 0 ? [] : store.tabs.slice(index + 1).map(t => t.id)
}
const batchCloseOpen = ref(false)
const batchCloseIds = ref<string[]>([])
/** 关闭多个标签;被固定的标签跳过,其余有未保存改动或临时草稿时先弹确认。 */
function requestCloseTabs(ids: string[]): void {
const valid = ids.filter(id => {
const tab = store.tabs.find(t => t.id === id)
return !!tab && !tab.pinned
})
if (!valid.length) return
const risky = valid.some(id => {
const tab = store.tabs.find(t => t.id === id)
if (!tab) return false
const dirty = id === store.activeTabId ? store.dirty : tab.dirty
return dirty || store.isScratchTab(id)
})
if (risky) {
batchCloseIds.value = valid
batchCloseOpen.value = true
return
}
store.closeTabsByIds(valid)
}
function confirmBatchClose(): void {
batchCloseOpen.value = false
const ids = batchCloseIds.value
batchCloseIds.value = []
store.closeTabsByIds(ids)
}
/**
* 草稿关闭三选一:保存到别处 / 删除 / 取消。
*
@@ -243,37 +362,66 @@ async function confirmCloseTab(): Promise<void> {
store.closeTab(id)
}
/**
* 放弃改动直接关闭标签(不保存)。
*
* 直接 `closeTab` 即可 —— 未保存的内容只在 store 的标签项 / 扁平 state 里,标签一移除
* 就随之丢弃。切走会触发 `docRevision` 变化,EditorHost 会顺手清掉挂起的自动保存定时器,
* 所以不会出现「关掉之后又被自动保存写回磁盘」。
*/
function discardAndCloseTab(): void {
const id = pendingCloseTabId.value
tabCloseConfirmOpen.value = false
if (!id) return
store.closeTab(id)
}
async function doClose(): Promise<void> {
if (store.anyDirty) {
closeConfirmOpen.value = true
return
}
await forceClose()
await closeWindow(true)
}
async function forceClose(): Promise<void> {
/**
* 关闭窗口。
*
* `saveFirst` 为真时逐个标签切换并保存(保存只作用于活动文档);为假则**不写盘**直接关
* —— 用户在确认框里选了「放弃修改并关闭」。
*
* 两条路都要落一次会话:会话记的是「开过哪些标签、光标在哪」,不是内容本身;放弃内容
* 不等于要丢掉下次恢复的入口。
*/
async function closeWindow(saveFirst: boolean): Promise<void> {
const original = store.activeTabId
// 逐个标签切换并保存(保存只作用于活动文档)
for (const tab of [...store.tabs]) {
store.activateTab(tab.id)
try {
await store.saveCurrent()
} catch {
/* 保存失败不阻塞关闭;脏数据仍在编辑器里 */
if (saveFirst) {
for (const tab of [...store.tabs]) {
store.activateTab(tab.id)
try {
await store.saveCurrent()
} catch {
/* 保存失败不阻塞关闭;脏数据仍在编辑器里 */
}
}
// 上面的循环把活动标签挪到了最后一个 —— 复原成用户关闭时正在看的那一篇,
// 会话里的「活动项」才与用户所见一致(不保存时活动标签没被动过,无需复原)
if (original) store.activateTab(original)
}
// 上面的循环把活动标签挪到了最后一个 —— 复原成用户关闭时正在看的那一篇,
// 会话里的「活动项」才与用户所见一致
if (original) store.activateTab(original)
// 关窗前记录会话(下次无目标打开时恢复)
store.saveSession()
win.close().catch(() => undefined)
}
/** 确认框里的「保存并关闭」。 */
const forceClose = () => closeWindow(true)
/** 确认框里的「放弃修改并关闭」:不写盘,直接关窗。 */
const discardAndCloseWindow = () => closeWindow(false)
/**
* 标签集合一变就落一次会话(防抖 300ms)。
*
* 只在关窗时写是不够的:标题栏的关闭按钮走 `forceClose` 会写,但 Alt+F4 / 任务栏
* 只在关窗时写是不够的:标题栏的关闭按钮走 `closeWindow` 会写,但 Alt+F4 / 任务栏
* 关闭不走前端流程,`onBeforeUnmount` 在 WebView 被销毁时也不保证执行 —— 会话就是这么
* 丢的。持续写把这个缺口堵上。
*
@@ -292,6 +440,117 @@ watch(sessionShape, () => {
}, 300)
})
// ===== Markdown 预览(标签栏的「眼睛」按钮) =====
/**
* 处于预览状态的标签 id。
*
* **按标签独立**而非窗口一个开关:预览是「看这一篇的渲染结果」,切到下一篇应当还是
* 编辑器本体。放在组件本地而不是 store,是因为它是纯视图状态(不需要跨窗口同步、
* 也不必进会话),关掉重开标签后重新点一下本来也是合理预期。
*/
const previewIds = ref<string[]>([])
// ===== 并排分屏 =====
/**
* 副面板展示的标签 id(空串 = 不分屏)。
*
* 副面板绑定的是**非活动标签**:主面板始终对应活动文档,副面板再开一个独立缓冲,
* 于是两个文档可同时编辑。若副面板对应标签被切到前台(成为活动标签)或已被关闭,
* 分屏自动收起 —— 否则同一标签会被两个面板同时持有,改动互相打架。
*/
const splitTabId = ref('')
const splitTab = computed(() => store.tabs.find(t => t.id === splitTabId.value) ?? null)
function openSplit(id: string): void {
if (id !== store.activeTabId) splitTabId.value = id
}
watch(
() => [splitTabId.value, store.activeTabId, store.tabs.length] as const,
() => {
if (splitTabId.value && (!splitTab.value || splitTabId.value === store.activeTabId)) {
splitTabId.value = ''
}
}
)
/**
* 预览用的 HTML 片段(`renderMarkdownFragment` 的产物,已过 DOMPurify)。
*
* 它只作为**渲染产物**存在,是否允许显示由 [`previewReady`] 决定 —— 绝不把「上一份
* 内容」当占位显示(先出现旧内容再被替换,观感很差)。
*/
const previewHtml = ref('')
/** 当前活动标签是否正处于预览 */
const previewActive = computed(
() => !!store.activeTabId && previewIds.value.includes(store.activeTabId)
)
/**
* 现有 `previewHtml` 是「为哪个标签、哪一版内容」渲染的(`null` = 还没渲染出来)。
*
* 用「标签 + 内容」双判据而不是一个 `loading` 布尔:切标签、切预览、内容被外部改动
* 这几种情况都会让已有产物失效,判据写在数据里就不用在每个入口手动置位。
*/
const previewRenderedFor = ref<{ id: string; content: string } | null>(null)
/** 当前是否可以直接显示 `previewHtml`(对得上活动标签与当前内容) */
const previewReady = computed(() => {
const rendered = previewRenderedFor.value
return (
rendered !== null && rendered.id === store.activeTabId && rendered.content === store.content
)
})
/** 渲染令牌:丢弃过期的异步渲染结果(快速切换标签 / 连续修改内容时) */
let previewToken = 0
/**
* 渲染模块缓存。
*
* 渲染链路(markdown-it + DOMPurify + highlight.js,约 1MB)与导出一样**按需 import**:
* 只有用户真的点开预览才付这份体积。缓存下来还能让后续渲染**同步完成** —— 否则每次
* 都要先过一个微任务,面板会闪一下「正在渲染」。
*/
let renderModule: typeof import('./editor/markdownExport') | null = null
/**
* 重新渲染预览(拿到的是**已消毒的 HTML 片段**,直接 `v-html`,不走 iframe)。
*
* `id` / `content` 在 await 之前取值:等待期间用户可能切了标签或改了内容,那样这次
* 结果就作废(令牌不一致),不能把旧文档的渲染挂到新文档上。
*/
async function refreshPreview(): Promise<void> {
const token = ++previewToken
if (!previewActive.value) return
const id = store.activeTabId
const content = store.content
// 先标失效:宁可短暂显示「正在渲染」,也不显示上一份内容
previewRenderedFor.value = null
try {
const mod = renderModule ?? (renderModule = await import('./editor/markdownExport'))
if (token !== previewToken || !previewActive.value) return
previewHtml.value = mod.renderMarkdownFragment(content)
previewRenderedFor.value = { id, content }
} catch (e) {
logger.error(`Markdown 预览渲染失败:${String(e)}`)
}
}
/** 切换某个标签的预览状态;开启时把它切到前台(否则点了看不到任何变化)。 */
function togglePreview(id: string): void {
const index = previewIds.value.indexOf(id)
if (index >= 0) {
previewIds.value.splice(index, 1)
return
}
previewIds.value.push(id)
// 切到前台;渲染由下面的 watch 触发(切标签与「开预览」都走同一条路径)
store.activateTab(id)
}
// 预览开关 / 内容变化要重渲染(深浅主题不需要:配色走 CSS 变量,自动跟随)。
// 非预览状态下的内容变化直接跳过 —— 否则每敲一个字都要重新渲染整篇。
watch([previewActive, () => store.content], () => {
if (!previewActive.value) return
void refreshPreview()
})
// ===== 编辑器命令转发 =====
function applyCommand(command: Command): void {
const view = hostRef.value?.getView() as EditorView | null | undefined
@@ -349,8 +608,12 @@ const searchDir = computed(() => {
const libraryPath = computed(() => store.info?.root ?? '')
function openSearch(scope: SearchScope = 'file'): void {
const wasOpen = searchOpen.value
searchScope.value = scope
searchOpen.value = true
// 已经打开时再次 Ctrl+F:把新选中的文本换进输入框(与输入栏内容不同才替换)。
// 关闭状态下由 EditorSearch 的 open 监听统一预填,这里不重复触发。
if (wasOpen) searchRef.value?.refillFromSelection()
}
/** 结果点击:打开文件并跳到那一行(检索期间文件可能已被改动,由 jumpToLine 夹取)。 */
@@ -451,6 +714,95 @@ async function doOpenFile(): Promise<void> {
}
}
// ===== 拖入文件打开 =====
/**
* 把拖入的路径逐个打开:文件夹进「目录」面板,文件按「库内笔记 / 库外文件」分流
* (分流规则在 `store.openDoc`)。
*
* # 为什么用 Tauri 原生拖放事件
*
* `dragDropEnabled` 默认开启时 Tauri 会替换 WebView2 的拖放处理器,HTML5 的
* `drop` 事件在 Windows 上拿不到外部文件路径;原生 `onDragDropEvent` 才能拿到
* `paths`。
*
* # 已知限制(非代码问题)
*
* Windows UIPI 会拦截从资源管理器(中完整性)拖入以**管理员**运行的窗口
* (高完整性),因此仅当 Thing 以普通权限运行时拖入才可用。
*/
async function onDroppedPaths(paths: string[]): Promise<void> {
for (const path of paths) {
try {
if ((await editorClient.pathKind(path)) === 'folder') {
await store.openFolder(path)
sidebarVisible.value = true
sidebarRef.value?.showDirectory()
} else {
await store.openDoc(path)
}
} catch (e) {
toast.error(`打开失败:${String(e)}`)
}
}
}
/**
* HTML5 `drop` 兜底。
*
* 正常情况下拖放由 Tauri 原生处理器接管,页面根本收不到 `drop`;但在 Windows 上
* 一旦原生处理器没接管(例如透明/分层窗口),浏览器就会把文件当「可放置内容」交给
* 页面 —— CodeMirror 的 contenteditable 会把**文件内容插进当前文档**,这就是
* 「拖入后内容被写进正在编辑的文件」的原因。这里 `preventDefault` 拦住这个默认
* 行为(同时消除拖动过程中的卡顿),并在能拿到绝对路径时照样打开。
*/
/** HTML5 dragover:亮遮罩(只有在 Tauri 原生拖放未接管时才会触发,见 onDomDrop)。 */
function onDomDragOver(): void {
dragOver.value = true
}
function onDomDrop(event: DragEvent): void {
// 拦 `drop` 默认行为:Chromium 对 contenteditable 的默认处理会把文件内容插进文档
event.preventDefault()
dragOver.value = false
const files = Array.from(event.dataTransfer?.files ?? [])
const paths = files
.map(f => (f as File & { path?: string }).path)
.filter((p): p is string => !!p)
if (paths.length) {
void onDroppedPaths(paths)
} else if (files.length) {
logger.warn(`拖放未走原生通道(files=${files.length},取不到绝对路径)`)
toast.error('未取到拖入文件的绝对路径(拖放被浏览器接管),请改用「打开文件」')
}
}
// ===== 主窗口发来的「在既有窗口加标签」 =====
/**
* 在**本窗口**打开一个目标(加标签 / 切到已开的标签)。
*
* 主窗口在发现有编辑器窗口时不再开新窗口,而是 `emitTo` 这个事件(见
* `openWindow.ts`)。监听放在组件而不是 store:store 的监听每个窗口都注册,
* 放进去会让主窗口自己把目标也「打开」一遍(主窗口没有编辑器界面,纯属副作用)。
*
* 三种目标与 `openEditorWindow` 的入参一一对应:`relPath`(库内笔记,笔记语义)、
* `path` + `folder`(目录面板)、`path`(库外文件)。
*/
async function onOpenTabRequest(payload: EditorOpenTabPayload): Promise<void> {
try {
if (payload.relPath) {
await store.openNote(payload.relPath)
} else if (payload.path && payload.folder) {
sidebarVisible.value = true
sidebarRef.value?.showDirectory()
await store.openFolder(payload.path)
} else if (payload.path) {
await store.openFile(payload.path)
}
} catch (e) {
toast.error(`打开失败:${String(e)}`)
}
}
// ===== 外部改动 =====
const externalConfirmOpen = ref(false)
@@ -540,11 +892,44 @@ onMounted(async () => {
window.addEventListener('storage', onStorageChange)
window.addEventListener('keydown', onKeydown, true)
// 拖入文件打开:走 Tauri 原生拖放事件(`enter/over` 亮遮罩,`drop` 取 paths)。
// 用 webview 而非 window 注册:拖放事件在 Rust 侧是发给 webview 的。
const selfWebview = getCurrentWebview()
unlistenDragDrop = await selfWebview.onDragDropEvent(event => {
const payload = event.payload
if (payload.type === 'enter' || payload.type === 'over') {
dragOver.value = true
} else if (payload.type === 'drop') {
dragOver.value = false
logger.info(`原生拖放 drop:${payload.paths.length} 项`)
void onDroppedPaths(payload.paths)
} else {
dragOver.value = false
}
})
logger.info(`拖放监听已注册:webview=${selfWebview.label}`)
// 主窗口要求「在既有窗口里加标签」:定向事件(`emitTo`),只有本窗口会收到
unlistenOpenTab = await listen<EditorOpenTabPayload>(EVENTS.editorOpenTab, event => {
void onOpenTabRequest(event.payload ?? {})
})
// 检索历史与面板高度来自 localStorage:尽早读取,状态栏按钮与结果面板都要用
searchStore.init()
// 主题 → 显示(窗口是隐藏创建的,这一步之后用户才第一次看到它)
// 主题 → 显示(窗口是隐藏创建的,这一步之后用户才第一次看到它)。
// 窗口深浅要按设置里的「跟随主应用主题 / 配色方案」推导,因此先取一次设置;
// `store.init()` 后面还会再读一次(无害,且那次要顺带做库扫描等初始化)。
await store.loadSettings()
await applyTheme()
// 任务栏身份:窗口级 AUMID(拆成独立任务栏按钮,不与主窗口合并)+ 组合图标
// (编辑器图形 + 右下角主程序图标)。**必须在 show() 之前**——任务栏按钮在窗口显示时
// 按 AUMID 决定分组,显示后再改往往要 hide/show 才生效。
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'editor' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try {
await win.show()
await win.setFocus()
@@ -580,6 +965,10 @@ onBeforeUnmount(() => {
darkMedia.removeEventListener('change', onThemeChange)
window.removeEventListener('storage', onStorageChange)
window.removeEventListener('keydown', onKeydown, true)
unlistenDragDrop?.()
unlistenDragDrop = null
unlistenOpenTab?.()
unlistenOpenTab = null
if (sessionTimer) {
clearTimeout(sessionTimer)
sessionTimer = null
@@ -660,7 +1049,12 @@ async function saveThenRedecode(): Promise<void> {
</script>
<template>
<div class="editor-window relative flex h-screen flex-col overflow-hidden text-foreground">
<div
class="editor-window relative flex h-screen flex-col overflow-hidden text-foreground"
@dragenter.prevent="onDomDragOver"
@dragover.prevent="onDomDragOver"
@drop.prevent="onDomDrop"
>
<!-- 自绘标题栏:仅标题区是拖动区,右侧按钮区不是(否则鼠标事件被拖动拦截) -->
<header class="flex h-9 shrink-0 items-center gap-1 border-b border-border px-2">
<!--
@@ -678,6 +1072,18 @@ async function saveThenRedecode(): Promise<void> {
<span v-if="store.dirty" class="size-1.5 shrink-0 rounded-full bg-primary" />
</div>
<!-- 设置:库设置 / 编辑器设置的快捷入口(在主界面对应「库」「编辑器」两页) -->
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="settingsOpen = true">
<Settings class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">设置</TooltipContent>
</Tooltip>
</TooltipProvider>
<div class="w-px h-4 bg-border shrink-0" />
<TooltipProvider :delay-duration="400">
@@ -736,7 +1142,17 @@ async function saveThenRedecode(): Promise<void> {
/>
<!-- 文档标签栏(多文档) -->
<EditorTabs v-if="store.tabs.length" @close="requestCloseTab" />
<EditorTabs
v-if="store.tabs.length"
:preview-ids="previewIds"
@close="requestCloseTab"
@toggle-preview="togglePreview"
@close-others="requestCloseTabs(tabIdsExcept($event))"
@close-left="requestCloseTabs(tabIdsLeftOf($event))"
@close-right="requestCloseTabs(tabIdsRightOf($event))"
@close-all="requestCloseTabs(store.tabs.map(t => t.id))"
@split="openSplit"
/>
<!-- 外部改动提示(有未保存改动时才会出现) -->
<div
@@ -764,16 +1180,19 @@ async function saveThenRedecode(): Promise<void> {
<!-- 统一搜索栏:横跨编辑列宽度,压在内容上方(IDEA 的 Find 栏位置) -->
<EditorSearch
ref="searchRef"
v-model:open="searchOpen"
v-model:scope="searchScope"
:dir-path="searchDir"
:library-path="libraryPath"
:get-view="getEditorView"
:doc-revision="store.docRevision"
@open-file="onSearchOpenFile"
@replaced="onPathReplaced"
/>
<main class="relative flex min-h-0 min-w-0 flex-1 flex-col">
<main class="flex min-h-0 min-w-0 flex-1">
<div class="relative flex min-h-0 min-w-0 flex-1 flex-col">
<div v-if="!store.hasDocument" class="flex min-h-0 flex-1 items-center justify-center">
<StateBlock
variant="empty"
@@ -800,6 +1219,73 @@ async function saveThenRedecode(): Promise<void> {
@wikilink="onWikilink"
/>
<!--
Markdown 预览:盖在编辑器**之上**而不是替换它 —— EditorHost 保持挂载,
来回切换不会丢撤销历史、光标与滚动位置。滚动交给项目的 ScrollArea(原生滚动条
在深色主题下与整体观感割裂),内容直接用 `v-html`(已消毒片段)。
# 为什么不是 iframe `srcdoc`(原先的做法)
Tauri 的插件(这里的 snap-layout)会向**每个 document** 注入初始化脚本,iframe
里的 `about:srcdoc` 也在其中:注入脚本在无 `__TAURI_INTERNALS__` 的帧里抛错,
而且帧被销毁重建后 `srcdoc` 的二次导航在 WebView2 上不可靠 —— 表现就是「退出
预览后再点预览,一片空白」。改用应用内渲染后这两个问题都不存在,样式改由
下面 `.md-preview` 的 scoped 规则隔离(安全边界仍是 DOMPurify,与导出同一套)。
已知限制:正文里**相对路径的本地图片**在预览中不会加载 —— 面板没有「库根 /
当前笔记目录」这个上下文(Live Preview 是靠 `editor_read_asset` 把图片取成
data URL 才显示的)。
-->
<!--
⚠️ 定位必须落在**外层这层 div**上,不能直接给 `ScrollArea` 加 `absolute`:
reka-ui 的 ScrollAreaRoot 自带内联 `position: relative`,内联样式压过 class,
于是 `absolute` 失效 —— 根节点退化成内容高度,viewport 没有可滚动空间
(症状就是「预览显示出来了,但滚不动」)。
-->
<div v-if="previewActive" class="absolute inset-0 bg-background">
<ScrollArea v-if="previewReady" class="h-full w-full">
<!-- eslint-disable-next-line vue/no-v-html -- 内容来自 renderMarkdownFragment(已过 DOMPurify) -->
<div class="md-preview" v-html="previewHtml" />
</ScrollArea>
<!-- 渲染未就绪:显示占位而**不是**上一份内容(旧内容先出现再被替换的观感很差) -->
<div v-else class="flex h-full items-center justify-center gap-2 text-xs text-muted-foreground">
<Loader2 class="size-3.5 animate-spin" />
正在渲染预览…
</div>
</div>
</div>
<!--
并排副面板:与主编辑列等宽,绑定**另一个标签**自己的缓冲(见 EditorHost 的 tabId)。
`:key` 保证换目标时整块重建(编辑器实例不可跨文档复用)。
-->
<div
v-if="splitTab"
class="relative flex min-h-0 w-1/2 min-w-0 flex-col border-l border-border"
>
<div class="flex h-8 shrink-0 items-center gap-1.5 border-b border-border px-2 text-xs">
<FileText v-if="splitTab.kind === 'note'" class="size-3.5 shrink-0 opacity-70" />
<FileCode2 v-else class="size-3.5 shrink-0 opacity-70" />
<span class="truncate font-medium text-foreground">{{ splitTab.name }}</span>
<Button
variant="ghost"
size="icon-sm"
class="ml-auto"
title="关闭分屏"
@click="splitTabId = ''"
>
<X class="size-3.5" />
</Button>
</div>
<EditorHost
:key="splitTab.id"
:tab-id="splitTab.id"
:is-dark="isDark"
:live-preview="store.viewMode === 'wysiwyg'"
class="min-h-0 flex-1"
/>
</div>
</main>
<!-- 目录 / 库检索结果面板:编辑列底部(IDE 的「Find in Path」工具窗位置) -->
@@ -914,14 +1400,31 @@ async function saveThenRedecode(): Promise<void> {
<!-- 快速打开(Ctrl+P) -->
<QuickOpen v-model:open="quickOpen" @select="store.openNote($event)" />
<!-- 关闭确认 -->
<ConfirmDialog
v-model:open="closeConfirmOpen"
title="有未保存的改动"
description="关闭窗口会丢失这些改动(自动保存会对未保存内容做最后一次尝试)。"
confirm-text="保存并关闭"
@confirm="forceClose"
/>
<!-- 设置对话框:库设置 / 编辑器设置(即时生效,无需保存按钮) -->
<EditorSettingsDialog v-model:open="settingsOpen" />
<!--
关闭窗口:三选一(保存并关闭 / 放弃修改并关闭 / 取消)。
与下面「关闭脏标签」同一套取舍 —— ConfirmDialog 只有两键,而「放弃修改」是用户
在这里最常需要的那条出路,不能藏在「取消」里。
-->
<Dialog :open="closeConfirmOpen" @update:open="closeConfirmOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>有未保存的改动</DialogTitle>
<DialogDescription>
「保存并关闭」会先把每个标签写入磁盘再退出;「放弃修改并关闭」直接丢弃这些改动。
</DialogDescription>
</DialogHeader>
<DialogFooter class="flex-col gap-2 sm:flex-col sm:space-x-0">
<Button class="w-full" @click="forceClose">保存并关闭</Button>
<Button variant="destructive" class="w-full" @click="discardAndCloseWindow">
放弃修改并关闭
</Button>
<Button variant="ghost" class="w-full" @click="closeConfirmOpen = false">取消</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 重载确认 -->
<ConfirmDialog
@@ -933,13 +1436,37 @@ async function saveThenRedecode(): Promise<void> {
@confirm="reloadFromExternal"
/>
<!-- 关闭标签确认 -->
<!--
关闭脏标签:三选一(保存并关闭 / 放弃修改并关闭 / 取消)。
不用 ConfirmDialog —— 它只有「确认 / 取消」两键,而「放弃修改」是用户在这里最常
需要的那条出路,不能藏在「取消」里(同下面草稿关闭对话框的取舍)。
-->
<Dialog :open="tabCloseConfirmOpen" @update:open="tabCloseConfirmOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>该标签有未保存的改动</DialogTitle>
<DialogDescription>
关闭标签会丢失这些改动。「保存并关闭」会先写入磁盘,再关闭标签。
</DialogDescription>
</DialogHeader>
<DialogFooter class="flex-col gap-2 sm:flex-col sm:space-x-0">
<Button class="w-full" @click="confirmCloseTab">保存并关闭</Button>
<Button variant="destructive" class="w-full" @click="discardAndCloseTab">
放弃修改并关闭
</Button>
<Button variant="ghost" class="w-full" @click="tabCloseConfirmOpen = false">取消</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 批量关闭确认:一次关多个标签,不做逐标签「保存 / 放弃」三选一 -->
<ConfirmDialog
v-model:open="tabCloseConfirmOpen"
title="该标签有未保存的改动"
description="关闭标签会丢失这些改动(选择「保存并关闭」会先保存再关闭)。"
confirm-text="保存并关闭"
@confirm="confirmCloseTab"
v-model:open="batchCloseOpen"
title="关闭多个标签"
variant="danger"
confirm-text="放弃修改并关闭"
:description="`选中的 ${batchCloseIds.length} 个标签中有未保存的改动或临时草稿,关闭会丢失这些改动。`"
@confirm="confirmBatchClose"
/>
<!--
@@ -988,6 +1515,22 @@ async function saveThenRedecode(): Promise<void> {
</DialogContent>
</Dialog>
<!-- 拖入提示遮罩(Tauri 原生拖放事件驱动;HTML5 拖放被 Tauri 接管,不可用) -->
<div
v-if="dragOver"
class="pointer-events-none absolute inset-0 z-50 flex items-center justify-center bg-background/70 backdrop-blur-sm"
>
<div
class="flex flex-col items-center gap-1.5 rounded-lg border-2 border-dashed border-primary px-8 py-6 text-center"
>
<NotebookPen class="size-6 text-primary" />
<span class="text-sm font-medium">松开以打开</span>
<span class="text-xs text-muted-foreground">
文件在本窗口打开,文件夹载入「目录」面板
</span>
</div>
</div>
<Toaster />
</div>
</template>
@@ -997,4 +1540,130 @@ async function saveThenRedecode(): Promise<void> {
.editor-window {
background: var(--popup-bg, var(--background));
}
/* ===== Markdown 预览 =====
与导出(`markdownExport` 的 EXPORT_STYLE)是同一套排版语言,但配色**全部换成应用语义
变量**:导出物要离线自洽,必须写死颜色;预览在应用内,深浅主题应当自动跟随。
预览**不套卡片外壳**:没有 max-width、没有阴影、没有灰底,正文直接铺满整个编辑区,
滚动交给外层的 ScrollArea(原生滚动条与本项目观感不一致,见 EditorHost 的同款处理)。 */
.md-preview {
padding: 16px 30px 72px;
color: var(--foreground);
font-size: 14.5px;
line-height: 1.75;
overflow-wrap: break-word;
}
.md-preview :deep(h1),
.md-preview :deep(h2),
.md-preview :deep(h3),
.md-preview :deep(h4),
.md-preview :deep(h5),
.md-preview :deep(h6) {
margin: 1.6em 0 0.6em;
font-weight: 600;
line-height: 1.35;
}
.md-preview :deep(h1) {
font-size: 1.7em;
padding-bottom: 0.3em;
border-bottom: 1px solid var(--border);
}
.md-preview :deep(h2) {
font-size: 1.4em;
padding-bottom: 0.3em;
border-bottom: 1px solid var(--border);
}
.md-preview :deep(h3) { font-size: 1.2em; }
.md-preview :deep(h4) { font-size: 1.05em; }
.md-preview :deep(p) { margin: 0 0 1em; }
.md-preview :deep(a) {
color: var(--primary);
text-decoration: none;
border-bottom: 1px solid color-mix(in srgb, var(--primary) 35%, transparent);
}
.md-preview :deep(a:hover) { border-bottom-color: currentColor; }
.md-preview :deep(strong) { font-weight: 600; }
.md-preview :deep(mark) {
padding: 0 0.15em;
background: var(--warning-soft);
color: inherit;
border-radius: 2px;
}
.md-preview :deep(img) { max-width: 100%; height: auto; border-radius: 6px; }
.md-preview :deep(blockquote) {
margin: 0 0 1em;
padding: 0.2em 0 0.2em 1em;
border-left: 4px solid var(--border);
color: var(--fg-secondary);
}
.md-preview :deep(blockquote > :last-child) { margin-bottom: 0; }
.md-preview :deep(ul),
.md-preview :deep(ol) { margin: 0 0 1em; padding-left: 1.6em; }
.md-preview :deep(li) { margin: 0.25em 0; }
.md-preview :deep(li.task-list-item) { margin-left: -1.35em; list-style: none; }
.md-preview :deep(input[type='checkbox']) { margin-right: 0.45em; vertical-align: middle; }
.md-preview :deep(code) {
padding: 0.15em 0.35em;
font-family: var(--font-mono);
font-size: 0.9em;
background: var(--subtle);
border-radius: 4px;
}
.md-preview :deep(pre) {
margin: 0 0 1em;
padding: 12px 14px;
overflow-x: auto;
background: var(--subtle);
border: 1px solid var(--border);
border-radius: 6px;
line-height: 1.55;
}
.md-preview :deep(pre code) {
padding: 0;
font-size: 0.875em;
background: transparent;
white-space: pre;
}
.md-preview :deep(table) {
display: block;
max-width: 100%;
margin: 0 0 1em;
overflow-x: auto;
border-collapse: collapse;
}
.md-preview :deep(th),
.md-preview :deep(td) { padding: 6px 12px; border: 1px solid var(--border); }
.md-preview :deep(th) { font-weight: 600; background: var(--subtle); }
.md-preview :deep(hr) { height: 1px; margin: 1.8em 0; border: 0; background: var(--border); }
/* 高亮 token:只做「语义色 → 主题变量」的映射,深浅各自可读(对应导出的固定配色表) */
.md-preview :deep(.hljs-comment),
.md-preview :deep(.hljs-quote) { color: var(--muted-foreground); font-style: italic; }
.md-preview :deep(.hljs-keyword),
.md-preview :deep(.hljs-selector-tag),
.md-preview :deep(.hljs-literal),
.md-preview :deep(.hljs-section) { color: var(--danger); }
.md-preview :deep(.hljs-string),
.md-preview :deep(.hljs-regexp),
.md-preview :deep(.hljs-addition) { color: var(--success); }
.md-preview :deep(.hljs-number),
.md-preview :deep(.hljs-symbol),
.md-preview :deep(.hljs-bullet) { color: var(--info); }
.md-preview :deep(.hljs-title),
.md-preview :deep(.hljs-name),
.md-preview :deep(.hljs-selector-id),
.md-preview :deep(.hljs-selector-class) { color: var(--info); }
.md-preview :deep(.hljs-attr),
.md-preview :deep(.hljs-attribute),
.md-preview :deep(.hljs-variable),
.md-preview :deep(.hljs-template-variable) { color: var(--warning); }
.md-preview :deep(.hljs-built_in),
.md-preview :deep(.hljs-type) { color: var(--info); }
.md-preview :deep(.hljs-meta),
.md-preview :deep(.hljs-doctag),
.md-preview :deep(.hljs-deletion) { color: var(--danger); }
.md-preview :deep(.hljs-tag) { color: var(--success); }
.md-preview :deep(.hljs-emphasis) { font-style: italic; }
.md-preview :deep(.hljs-strong) { font-weight: 600; }
</style>
@@ -22,7 +22,7 @@
* 清空子层缓存 → 重读根 → 并行重读所有已展开目录。展开的目录通常只有几个,代价可忽略;
* 换来的是「缓存里的路径永远有效」这条不变量(拖放目标、选中集都按路径工作)。
*/
import { computed, ref, watch } from 'vue'
import { computed, nextTick, ref, watch } from 'vue'
import {
AppWindow,
ArrowUp,
@@ -36,6 +36,7 @@ import {
FolderOpen,
FolderPlus,
Loader2,
LocateFixed,
Pencil,
RotateCw,
SquarePen,
@@ -256,6 +257,90 @@ async function refresh(): Promise<void> {
}
}
// ===== 定位当前文件 =====
//
// 树是懒加载的,「定位」必须顺着路径逐级展开并**按需拉取**中间层,否则目标行根本
// 不在 `rows` 里。虚线是:只对当前打开的库外文件(`fileDoc.path`)且确实位于本目录根
// 之下时才提供入口 —— 否则点了也没有意义。
/** 树内容容器(滚动目标用) */
const treeRef = ref<HTMLElement | null>(null)
/** 需要短暂高亮的路径(定位反馈) */
const locateTarget = ref('')
function normalizePath(p: string): string {
return p.replace(/\//g, '\\').replace(/\\+$/, '')
}
const currentFilePath = computed(() => {
if (store.kind === 'file') return store.fileDoc?.path ?? ''
// 库内笔记也可定位:只要它所在的库目录被当作本地目录打开过,就能在这棵树里找到
if (store.kind === 'note' && store.currentRelPath) return store.noteAbsPath(store.currentRelPath)
return ''
})
/** 当前文件是否在本目录根之下(决定定位按钮是否出现)。 */
const canLocateCurrent = computed(() => {
const file = currentFilePath.value
const root = rootCwd.value
if (!file || !root) return false
const fn = normalizePath(file).toLowerCase()
const rn = normalizePath(root).toLowerCase()
return fn.startsWith(`${rn}\\`)
})
/** 某个目录当前可见的子项(根走 `dirListing`,其余走子层缓存)。 */
function entriesOf(dir: string): DirEntry[] {
if (normalizePath(dir).toLowerCase() === normalizePath(rootCwd.value).toLowerCase()) {
return rootEntries.value
}
return childrenMap.value.get(dir) ?? []
}
/** 确保某目录的子层已缓存(根无需加载)。 */
async function ensureChildren(dir: string): Promise<void> {
if (normalizePath(dir).toLowerCase() === normalizePath(rootCwd.value).toLowerCase()) return
if (!childrenMap.value.has(dir)) await loadChildren(dir)
}
/** 展开到当前文件的父目录,滚动到该行并短暂高亮。 */
async function locateCurrent(): Promise<void> {
const file = currentFilePath.value
const root = rootCwd.value
if (!file || !root || !canLocateCurrent.value) return
// 过滤会隐藏目标行,先清掉
filter.value = ''
const rootNorm = normalizePath(root)
const relative = normalizePath(file).slice(rootNorm.length).replace(/^\\+/, '')
const segments = relative.split('\\').filter(Boolean)
segments.pop() // 去掉文件名,只展开到父目录
const next = new Set(expanded.value)
let current = rootNorm
for (const segment of segments) {
await ensureChildren(current)
const found = entriesOf(current).find(e => e.kind === 'dir' && e.name === segment)
if (!found) {
current = ''
break
}
next.add(found.path)
current = found.path
}
expanded.value = next
if (!current) return
await ensureChildren(current) // 让目标文件行出现在列表里
locateTarget.value = file
await nextTick()
const rows = treeRef.value?.querySelectorAll<HTMLElement>('[data-path]')
const target = rows ? Array.from(rows).find(el => el.dataset.path === file) : undefined
target?.scrollIntoView({ block: 'center' })
window.setTimeout(() => {
if (locateTarget.value === file) locateTarget.value = ''
}, 1400)
}
function openEntry(entry: DirEntry): void {
if (entry.kind === 'dir') {
toggleDir(entry)
@@ -589,6 +674,16 @@ function menuDelete(): void {
>
<RotateCw class="size-3.5" :class="store.dirLoading && 'animate-spin'" />
</Button>
<!-- 定位当前文件:仅当前打开的文件位于本目录之下时出现(否则无意义) -->
<Button
v-if="canLocateCurrent"
variant="ghost"
size="icon-sm"
title="定位当前文件(展开目录树并高亮)"
@click="locateCurrent"
>
<LocateFixed class="size-3.5" />
</Button>
<span class="ml-1 truncate text-[11px] font-medium text-fg-secondary" :title="store.dirListing?.cwd">
{{ cwdName }}
</span>
@@ -631,7 +726,7 @@ function menuDelete(): void {
<!-- 树 -->
<ScrollArea v-if="store.dirListing" class="min-h-0 flex-1">
<div class="px-1.5 pb-2">
<div ref="treeRef" class="px-1.5 pb-2">
<div v-if="store.dirLoading && !rootEntries.length" class="flex items-center justify-center gap-2 p-4">
<Loader2 class="size-3.5 animate-spin text-muted-foreground" />
<span class="text-[11px] text-muted-foreground">正在读取目录…</span>
@@ -649,14 +744,16 @@ function menuDelete(): void {
<div
v-for="row in rows"
:key="row.entry.path"
:data-path="row.entry.path"
class="group flex h-7 cursor-pointer items-center gap-1 rounded-sm pr-1.5 transition-colors duration-150"
:class="[
selected.has(row.entry.path)
? 'bg-primary-soft text-primary-soft-text'
: store.fileDoc?.path === row.entry.path
: currentFilePath === row.entry.path
? 'bg-row-selected text-primary-soft-text'
: 'text-fg-secondary hover:bg-row-hover hover:text-foreground',
dropTarget === row.entry.path && 'ring-1 ring-primary ring-inset'
dropTarget === row.entry.path && 'ring-1 ring-primary ring-inset',
locateTarget === row.entry.path && 'ring-2 ring-primary ring-inset'
]"
:style="{ paddingLeft: `${row.depth * 12 + 4}px` }"
:title="row.entry.path"
+74 -35
View File
@@ -36,15 +36,27 @@ import {
} from '../editor/core'
import { editorBackground } from '../editor/themes'
import { createLogger } from '@/lib/logger'
import type { LanguageLoader } from '../editor/languages'
import type { Extension } from '@codemirror/state'
const logger = createLogger('editor')
const props = defineProps<{
/** 应用当前是否深色(跟随应用主题时用于取深/浅变体) */
/**
* 编辑器**窗口**当前是否深色(由 EditorWindow 按「跟随主应用主题 / 配色方案」推导)。
* 用于:跟随应用时按它取深浅变体,配色方案为「跟随系统」时按它取 VS Code 深/浅。
*/
isDark: boolean
/** 是否启用 Live Preview */
livePreview: boolean
/**
* 绑定的标签 id(并排副面板用)。
*
* 缺省(主面板)= 绑定 store 的**扁平活动文档**;给出 id 时 = 绑定该标签**自己的缓冲**
* (读 `tab.content`、写 `tab.content` 并置脏、保存走 `saveTab`)。副面板永远绑定非活动
* 标签,因此不会与主面板争抢扁平 state。
*/
tabId?: string
}>()
const emit = defineEmits<{
@@ -57,6 +69,29 @@ const emit = defineEmits<{
const store = useEditorStore()
const hostRef = ref<HTMLDivElement | null>(null)
/** 是否为「绑定某个标签」的副面板(否则为主面板,读扁平 state)。 */
const isPane = computed(() => !!props.tabId)
/** 副面板绑定的标签(主面板为 null)。 */
const boundTab = computed(() =>
props.tabId ? store.tabs.find(t => t.id === props.tabId) ?? null : null
)
/** 需要读取的文档属性:主面板取扁平 state,副面板取标签缓冲。 */
const paneContent = computed(() => (isPane.value ? boundTab.value?.content ?? '' : store.content))
const paneLarge = computed(() =>
isPane.value ? boundTab.value?.fileDoc?.large ?? false : store.fileDoc?.large ?? false
)
const paneKind = computed(() => (isPane.value ? boundTab.value?.kind ?? 'none' : store.kind))
const paneRelPath = computed(() =>
isPane.value ? boundTab.value?.relPath ?? '' : store.currentRelPath
)
const paneRevision = computed(() =>
isPane.value ? boundTab.value?.docRevision ?? 0 : store.docRevision
)
const paneLanguage = computed<LanguageLoader>(() =>
isPane.value ? boundTab.value?.language ?? (() => Promise.resolve(null)) : store.language
)
/**
* 编辑器外壳底色:跟随当前**实际生效**的主题。
*
@@ -78,7 +113,8 @@ let languageSeq = 0
function currentConfig(): EditorConfig {
const s = store.settings
const large = store.fileDoc?.large ?? false
const large = paneLarge.value
const note = paneKind.value === 'note'
return {
livePreview: props.livePreview,
showLineNumbers: s.showLineNumbers,
@@ -95,11 +131,11 @@ function currentConfig(): EditorConfig {
language: () => null,
largeFile: large,
autocomplete: s.autocomplete,
wikilink: s.wikilink && store.kind === 'note',
wikilink: s.wikilink && note,
onWikilink: target => emit('wikilink', target),
// 图片预览只在库内笔记里有意义(库外文件没有库根上下文)
currentRelPath: store.kind === 'note' ? store.currentRelPath : '',
images: store.kind === 'note'
currentRelPath: note ? paneRelPath.value : '',
images: note
}
}
@@ -109,16 +145,21 @@ function scheduleAutosave(): void {
if (autosaveTimer) clearTimeout(autosaveTimer)
autosaveTimer = setTimeout(() => {
autosaveTimer = null
void store.saveCurrent().catch(() => undefined)
void persist().catch(() => undefined)
}, ms)
}
/** 落盘:主面板存活动文档,副面板存它绑定的标签。 */
function persist(): Promise<void> {
return isPane.value && props.tabId ? store.saveTab(props.tabId) : store.saveCurrent()
}
function flushAutosave(): void {
if (autosaveTimer) {
clearTimeout(autosaveTimer)
autosaveTimer = null
}
void store.saveCurrent().catch(() => undefined)
void persist().catch(() => undefined)
}
/** 加载并应用当前文档的语言扩展。 */
@@ -126,7 +167,7 @@ async function applyLanguage(seq: number): Promise<void> {
if (!view) return
let extension: Extension | null = null
try {
extension = await store.language()
extension = await paneLanguage.value()
} catch (e) {
logger.warn(`语言扩展加载失败:${String(e)}`)
}
@@ -140,17 +181,21 @@ onMounted(() => {
view = new EditorView({
parent: hostRef.value,
state: createEditorState({
doc: store.content,
doc: paneContent.value,
config: currentConfig(),
onDocChanged: doc => {
if (applyingDoc) return
store.setContent(doc)
if (isPane.value && props.tabId) store.setTabContent(props.tabId, doc)
else store.setContent(doc)
scheduleAutosave()
},
onSelectionChanged: (line, column) => emit('cursor-moved', line, column)
// 副面板的光标不该覆盖状态栏(状态栏跟随活动文档)
onSelectionChanged: (line, column) => {
if (!isPane.value) emit('cursor-moved', line, column)
}
})
})
appliedRevision = store.docRevision
appliedRevision = paneRevision.value
void applyLanguage(++languageSeq)
})
@@ -160,20 +205,20 @@ onMounted(() => {
* 用 `docRevision` 而不是路径:重载同一篇时路径没变,但内容必须被换掉。
*/
watch(
() => store.docRevision,
() => {
paneRevision,
revision => {
if (!view) return
if (autosaveTimer) {
clearTimeout(autosaveTimer)
autosaveTimer = null
}
if (appliedRevision === store.docRevision) return
appliedRevision = store.docRevision
if (appliedRevision === revision) return
appliedRevision = revision
// 目标光标行要在 replaceDoc **之前**取:替换会派发 selection 变化,
// updateListener 随即把 store.cursorLine 覆盖成 1,之后再读就只剩第 1 行了。
const restoreLine = store.cursorLine
const restoreLine = isPane.value ? 1 : store.cursorLine
applyingDoc = true
replaceDoc(view, store.content)
replaceDoc(view, paneContent.value)
// 标签切换 / 会话恢复:按 store.cursorLine 复位光标(默认第 1 行不动)
if (restoreLine > 1) {
const line = Math.min(restoreLine, view.state.doc.lines)
@@ -186,12 +231,9 @@ watch(
)
/** 语言变化(异步加载完成 / 切换到另一种语言)。 */
watch(
() => store.language,
() => {
void applyLanguage(++languageSeq)
}
)
watch(paneLanguage, () => {
void applyLanguage(++languageSeq)
})
/**
* 切换笔记:Live Preview 的图片预览按「相对当前笔记所在目录」解析目标,
@@ -200,21 +242,18 @@ watch(
* 只动 mode 与 wikilink 两个 compartment:语言由 `applyLanguage` 单独负责,
* 在这里一并 reconfigure 会把刚异步加载好的语言重置掉。
*/
watch(
() => store.currentRelPath,
() => {
if (!view) return
try {
reconfigureEditor(view, currentConfig())
} catch (e) {
logger.error(`切换笔记后重配置失败:${String(e)}`)
}
watch(paneRelPath, () => {
if (!view) return
try {
reconfigureEditor(view, currentConfig())
} catch (e) {
logger.error(`切换笔记后重配置失败:${String(e)}`)
}
)
})
/** 设置 / 深浅 / 视图模式 / 文档类型变化:热重配置,不重建编辑器。 */
watch(
() => [store.settings, props.isDark, props.livePreview, store.fileDoc?.large],
() => [store.settings, props.isDark, props.livePreview, paneLarge.value],
() => {
if (!view) return
try {
+75 -12
View File
@@ -89,7 +89,7 @@ import {
} from '@lucide/vue'
// 别名:`open` 与本组件的 `open` prop 同名,会和模板里的绑定撞名
import { open as openDialog } from '@tauri-apps/plugin-dialog'
import type { EditorView } from '@codemirror/view'
import { EditorView } from '@codemirror/view'
import {
SearchQuery,
replaceAll as cmReplaceAll,
@@ -116,6 +116,13 @@ const props = defineProps<{
libraryPath: string
/** 取当前 CM6 视图(未打开文档时为 null) */
getView: () => EditorView | null
/**
* 当前活动文档的装载版本(`editorStore.docRevision`)。
*
* 切换标签 / 重载文档时它会自增,用来把「当前文件」范围的搜索**换成新标签**做:
* 命中下标是旧文档的字符偏移,不重算就会算错计数、甚至在更短的新文档里越界。
*/
docRevision: number
}>()
const emit = defineEmits<{
@@ -278,22 +285,53 @@ const scopeHint = computed(() => {
})
/**
* Ctrl+F 打开时用**当前选中的文本**填关键词(IDEA / VS Code 的行为)。
* 当前选区里可作关键词的文本(空串 = 没有可用的单行选中)。
*
* 只取「非空且不跨行」的选区:跨行片段当关键词没有意义 —— 当前文件里换行只是字面量,
* 磁盘 grep 又是逐行匹配的,拿一整段代码当搜索词只会得到 0 命中。此时沿用上一次的
* 关键词,由调用方在输入框里全选,方便直接覆盖输入。
* 磁盘 grep 又是逐行匹配的,拿一整段代码当搜索词只会得到 0 命中。
*/
function selectionKeyword(): string {
const view = props.getView()
if (!view) return ''
const range = view.state.selection.main
if (range.empty) return ''
const text = view.state.sliceDoc(range.from, range.to)
if (!text || text.includes('\n') || text.includes('\r')) return ''
return text
}
/**
* Ctrl+F 打开时用**当前选中的文本**填关键词(IDEA / VS Code 的行为)。
*
* 没有可用的选中时沿用上一次的关键词,由调用方在输入框里全选,方便直接覆盖输入。
*/
function prefillFromSelection(): void {
const view = props.getView()
if (!view) return
const range = view.state.selection.main
if (range.empty) return
const text = view.state.sliceDoc(range.from, range.to)
if (!text || text.includes('\n') || text.includes('\r')) return
const text = selectionKeyword()
if (!text) return
pattern.value = text
}
/**
* 搜索栏**已经打开**时再次 Ctrl+F。
*
* - 有新选中文本、且与输入框内容不同 → 换进输入框并全选(便于直接覆盖输入);
* - 没有可填充的新文本(未选中,或选中与当前关键词相同)→ 仅把焦点放回输入框。
*
* 两种情况下**都要聚焦**:Ctrl+F 的语义是「回到查找框」,不该因为选区恰好与关键词
* 相同就毫无反应。
*/
function refillFromSelection(): void {
const text = selectionKeyword()
if (text && text !== pattern.value) {
pattern.value = text
void nextTick(() => patternRef.value?.focusAndSelect())
return
}
void nextTick(() => patternRef.value?.focus())
}
defineExpose({ refillFromSelection })
// ===== 当前文件:CM6 search API =====
function buildQuery(): SearchQuery {
@@ -316,14 +354,19 @@ function clearFileHighlights(): void {
fileMatches = []
}
/** 选中第 index 处命中(0 起)并滚动到可见。 */
/**
* 选中第 index 处命中(0 起)并把该行**滚动到页面垂直居中**。
*
* 不用 `scrollIntoView: true`(CM6 默认的最小滚动):命中在视口下方时它只会把命中行
* 顶到**最后一行**,上下没有余量,看不出前后文。显式 `y: 'center'` 让命中居中。
*/
function selectMatch(index: number): void {
const view = props.getView()
const range = fileMatches[index]
if (!view || !range) return
view.dispatch({
selection: { anchor: range.from, head: range.to },
scrollIntoView: true
effects: EditorView.scrollIntoView(range.from, { y: 'center' })
})
}
@@ -590,6 +633,26 @@ watch(
if (isFile.value) runFileSearch()
}
)
/**
* 切换标签 / 重载文档:当前文件范围的搜索跟着换到新文档重算一次。
*
* `fileMatches` / `matchCount` 是**旧文档的字符偏移**,不重算的话计数会停留在上一篇的
* 数字,「上一个 / 下一个」还会拿旧偏移去 dispatch 选区 —— 新文档更短时越界报错,
* 表现就是「切到新标签后搜索失灵」。
*
* 用 `flush: 'post'`:编辑器里文档的整篇替换由 `EditorHost` 的 pre watcher 完成,
* post 回调保证跑在它**之后**,否则会拿还没换过的旧文档去搜。目录 / 笔记库范围不重算
* —— 那是磁盘扫描,一律由回车 / 点搜索按钮发起。
*/
watch(
() => props.docRevision,
() => {
if (!props.open || !isFile.value) return
runFileSearch()
},
{ flush: 'post' }
)
</script>
<template>
@@ -0,0 +1,420 @@
<script setup lang="ts">
/**
* 编辑器窗口内的设置对话框。
*
* # 为什么把主界面的设置搬到这里
*
* 「库」与「编辑器」两页的设置本来只在主模块页可达 —— 用户把编辑器窗口拖到副屏、
* 或在专注写作时,改个字号 / 换库都得先切回主界面。这里把这些**高频设置**就地暴露
* 出来(导入导出 / WebDAV 这类重面板不搬)。
*
* # 改完即全局生效
*
* 读写都走当前窗口的 `editorStore`:`patchSettings` 落盘后 Rust 广播 `editor-settings`
* 事件,主窗口与其它编辑器窗口据此重新读取设置;库根同理(`editor-library-changed`)。
* 因此这里没有「保存」按钮,也不需要与主窗口做额外同步。
*/
import { ref } from 'vue'
import { open as openDialog } from '@tauri-apps/plugin-dialog'
import { openPath } from '@tauri-apps/plugin-opener'
import {
Copy,
FolderOpen,
Library,
NotebookPen,
Palette,
RefreshCw,
Settings,
Tags
} from '@lucide/vue'
import { toast } from 'vue-sonner'
import {
Dialog,
DialogContent,
DialogHeader,
DialogTitle
} from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Switch } from '@/components/ui/switch'
import { ScrollArea } from '@/components/ui/scroll-area'
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue
} from '@/components/ui/select'
import { ConfirmDialog, SegmentedNav, SettingGroup, SettingRow } from '@/components/common'
import { useEditorStore } from '@/stores/editorStore'
import { EDITOR_THEME_OPTIONS } from '../editor/themes'
import type { EditorSettings } from '@/types/editor'
defineProps<{ open: boolean }>()
const emit = defineEmits<{ 'update:open': [value: boolean] }>()
const store = useEditorStore()
/** 当前分区(默认「编辑器设置」—— 在编辑器窗口里调整外观 / 行为是最常见的诉求) */
const section = ref<'library' | 'editor'>('editor')
const sections = [
{ value: 'library', label: '库设置', icon: Library },
{ value: 'editor', label: '编辑器设置', icon: Palette }
]
// ===== 设置写入(即时生效) =====
function commit(patch: Partial<EditorSettings>): void {
void store.patchSettings(patch)
}
function onNumber(
patchKey: 'fontSize' | 'lineHeight' | 'tabSize' | 'autosaveMs' | 'maxFileSizeMb',
event: Event
): void {
const value = Number((event.target as HTMLInputElement).value)
if (!Number.isFinite(value)) return
commit({ [patchKey]: value } as Partial<EditorSettings>)
}
// ===== 库根 =====
const resetRootOpen = ref(false)
async function pickLibraryRoot(): Promise<void> {
try {
const selected = await openDialog({ directory: true, multiple: false, title: '选择笔记库目录' })
if (typeof selected !== 'string') return
await store.setLibraryRoot(selected)
toast.success('已切换笔记库')
} catch (e) {
toast.error(`切换失败:${String(e)}`)
}
}
async function resetLibraryRoot(): Promise<void> {
try {
await store.setLibraryRoot(null)
toast.success('已恢复默认库目录')
} catch (e) {
toast.error(`恢复失败:${String(e)}`)
} finally {
resetRootOpen.value = false
}
}
async function revealRoot(): Promise<void> {
if (!store.libraryRoot) return
try {
await openPath(store.libraryRoot)
} catch (e) {
toast.error(`打开目录失败:${String(e)}`)
}
}
async function copyRoot(): Promise<void> {
if (!store.libraryRoot) return
try {
await navigator.clipboard.writeText(store.libraryRoot)
toast.success('库路径已复制')
} catch {
toast.error('复制失败')
}
}
// ===== 索引 =====
const rebuilding = ref(false)
async function rebuildIndex(): Promise<void> {
rebuilding.value = true
try {
await store.rebuildIndex()
await store.refreshLibrary()
toast.success('索引已重建')
} catch (e) {
toast.error(`重建索引失败:${String(e)}`)
} finally {
rebuilding.value = false
}
}
</script>
<template>
<Dialog :open="open" @update:open="emit('update:open', $event)">
<DialogContent class="max-h-[85vh] sm:max-w-2xl">
<DialogHeader class="shrink-0">
<DialogTitle class="flex items-center gap-2 text-base">
<Settings class="size-4 text-primary" />
设置
</DialogTitle>
</DialogHeader>
<SegmentedNav v-model="section" :items="sections" block class="shrink-0" />
<ScrollArea class="max-h-[60vh] pr-3">
<!-- ===== 库设置 ===== -->
<div v-if="section === 'library'" class="flex flex-col gap-4 pb-1">
<SettingGroup
title="笔记库"
description="笔记以 Markdown 文件形式保存在该目录;切换库只改变指向,原目录内容不会被移动"
>
<SettingRow label="库目录" :description="store.libraryRoot || '—'">
<div class="flex flex-wrap items-center gap-2">
<Button variant="outline" size="sm" :disabled="!store.libraryRoot" @click="copyRoot">
<Copy class="size-3.5" />复制
</Button>
<Button variant="outline" size="sm" :disabled="!store.libraryRoot" @click="revealRoot">
<FolderOpen class="size-3.5" />浏览
</Button>
<Button variant="outline" size="sm" @click="pickLibraryRoot">
<NotebookPen class="size-3.5" />切换…
</Button>
<Button
v-if="store.info?.isCustom"
variant="ghost"
size="sm"
class="text-muted-foreground"
@click="resetRootOpen = true"
>
恢复默认
</Button>
</div>
</SettingRow>
<SettingRow label="重新扫描" description="在应用外新增或修改文件后,手动刷新库内容">
<Button variant="outline" size="sm" @click="store.refreshLibrary()">
<RefreshCw class="size-3.5" />刷新
</Button>
</SettingRow>
</SettingGroup>
<SettingGroup
title="索引与检索"
description="全文检索与标签依赖库内的 SQLite 索引;删掉也能从 Markdown 文件完整重建"
>
<SettingRow label="索引状态" :description="store.indexStats?.dbPath || '尚未建立索引'">
<div class="flex items-center gap-3 text-[13px] text-fg-secondary">
<span class="tabular-nums">笔记 {{ store.indexStats?.noteCount ?? 0 }}</span>
<span class="tabular-nums">文件 {{ store.indexStats?.fileCount ?? 0 }}</span>
<span class="flex items-center gap-1 tabular-nums">
<Tags class="size-3.5" />{{ store.indexStats?.tagCount ?? 0 }}
</span>
</div>
</SettingRow>
<SettingRow
label="重建索引"
description="按文件重新解析标题、标签与双链(库很大时需要一点时间)"
>
<Button
variant="outline"
size="sm"
:disabled="rebuilding || store.indexing"
@click="rebuildIndex"
>
<RefreshCw class="size-3.5" :class="rebuilding && 'animate-spin'" />重建
</Button>
</SettingRow>
<SettingRow
label="单文件大小上限"
description="超过该大小的文件会关闭所见即所得 / 折叠 / 补全,单位 MB"
control-width="wide"
>
<Input
type="number"
min="1"
max="100"
:model-value="store.settings.maxFileSizeMb"
@change="onNumber('maxFileSizeMb', $event)"
/>
</SettingRow>
</SettingGroup>
</div>
<!-- ===== 编辑器设置 ===== -->
<div v-else class="flex flex-col gap-4 pb-1">
<SettingGroup title="编辑器外观">
<SettingRow
label="配色方案"
description="「跟随主应用主题」关闭时,窗口按本方案取色与深浅"
control-width="wide"
>
<Select
:model-value="String(store.settings.editorTheme)"
@update:model-value="v => commit({ editorTheme: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem v-for="opt in EDITOR_THEME_OPTIONS" :key="opt.value" :value="opt.value">
{{ opt.label }}
</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow label="跟随主应用主题" description="打开时编辑器窗口整体跟随主应用主题;关闭时由上方「配色方案」决定,窗口内外深浅一致">
<Switch
:model-value="store.settings.followAppTheme"
@update:model-value="v => commit({ followAppTheme: v === true })"
/>
</SettingRow>
<SettingRow label="字体族" description="留空使用内置等宽字体栈" control-width="wide">
<Input
:model-value="store.settings.fontFamily"
placeholder="Cascadia Code, Consolas, …"
@change="(e: Event) => commit({ fontFamily: (e.target as HTMLInputElement).value })"
/>
</SettingRow>
<SettingRow label="字号" description="单位 px" control-width="wide">
<Input
type="number"
min="10"
max="32"
:model-value="store.settings.fontSize"
@change="onNumber('fontSize', $event)"
/>
</SettingRow>
<SettingRow label="行高" description="倍数,建议 1.5 ~ 2.0" control-width="wide">
<Input
type="number"
step="0.1"
min="1"
max="3"
:model-value="store.settings.lineHeight"
@change="onNumber('lineHeight', $event)"
/>
</SettingRow>
<SettingRow label="字体连字" description="启用 ligatures(如 => 显示为箭头)">
<Switch
:model-value="store.settings.ligatures"
@update:model-value="v => commit({ ligatures: v === true })"
/>
</SettingRow>
<SettingRow label="显示行号">
<Switch
:model-value="store.settings.showLineNumbers"
@update:model-value="v => commit({ showLineNumbers: v === true })"
/>
</SettingRow>
<SettingRow
label="显示大纲"
description="在编辑区右侧抽屉显示标题树(Ctrl+Shift+O 可临时切换)"
>
<Switch
:model-value="store.settings.showOutline"
@update:model-value="v => commit({ showOutline: v === true })"
/>
</SettingRow>
</SettingGroup>
<SettingGroup title="编辑器行为">
<SettingRow
label="所见即所得"
description="Live Preview:语法符号在非光标行隐藏、光标行显形;关闭后为纯源码 + 高亮"
>
<Switch
:model-value="store.settings.livePreview"
@update:model-value="v => commit({ livePreview: v === true })"
/>
</SettingRow>
<SettingRow label="默认视图" description="新开编辑器窗口时的初始视图" control-width="wide">
<Select
:model-value="String(store.settings.defaultView)"
@update:model-value="v => commit({ defaultView: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem value="wysiwyg">所见即所得</SelectItem>
<SelectItem value="source">源码</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow
label="自动保存"
description="停止输入后延迟保存,单位毫秒;0 = 关闭(仅 Ctrl+S)"
control-width="wide"
>
<Input
type="number"
min="0"
max="10000"
step="100"
:model-value="store.settings.autosaveMs"
@change="onNumber('autosaveMs', $event)"
/>
</SettingRow>
<SettingRow label="Tab 宽度" description="按空格数计" control-width="wide">
<Input
type="number"
min="1"
max="8"
:model-value="store.settings.tabSize"
@change="onNumber('tabSize', $event)"
/>
</SettingRow>
<SettingRow label="自动补全" description="括号自动闭合与代码补全(大文件会临时关闭)">
<Switch
:model-value="store.settings.autocomplete"
@update:model-value="v => commit({ autocomplete: v === true })"
/>
</SettingRow>
<SettingRow
label="识别 [[双链]]"
description="按 Obsidian 语义解析双链并写入索引(反链面板留待后续)"
>
<Switch
:model-value="store.settings.wikilink"
@update:model-value="v => commit({ wikilink: v === true })"
/>
</SettingRow>
<SettingRow
label="复用文档窗口"
description="同一篇笔记重复打开时聚焦已有窗口,而不是开出第二个"
>
<Switch
:model-value="store.settings.reuseWindow"
@update:model-value="v => commit({ reuseWindow: v === true })"
/>
</SettingRow>
<SettingRow
label="导出时高亮代码"
description="关闭后导出的 HTML 里代码块是纯黑白,适合黑白打印机"
>
<Switch
:model-value="store.settings.exportHighlight"
@update:model-value="v => commit({ exportHighlight: v === true })"
/>
</SettingRow>
<SettingRow label="新建时选模板" description="关闭后用上次选中的模板直接新建">
<Switch
:model-value="store.settings.showTemplatePicker"
@update:model-value="v => commit({ showTemplatePicker: v === true })"
/>
</SettingRow>
</SettingGroup>
</div>
</ScrollArea>
<ConfirmDialog
v-model:open="resetRootOpen"
title="恢复默认库目录"
description="笔记不会丢失:仅把库根指回应用数据目录下的默认位置,原目录内容保持不动。"
confirm-text="恢复默认"
@confirm="resetLibraryRoot"
/>
</DialogContent>
</Dialog>
</template>
+586 -24
View File
@@ -5,41 +5,603 @@
* 一个编辑器窗口内可同时打开多篇文档,每个标签**独立**保存内容、编码 / 换行、
* 视图模式与未保存状态。标签的「脏」指示点用 store 的 `tabViews`:活动标签取
* 实时值(正在敲字),后台标签取切换时收回的快照。
*
* # Markdown 标签多一个「预览」按钮
*
* 预览状态同样**按标签独立**(`previewIds` 由父组件 `EditorWindow` 持有并渲染面板):
* 一个标签在预览渲染结果时,切到别的标签仍是正常的编辑器 —— 这与「视图模式按标签存」
* 的模型一致(见 `DocumentTab.viewMode`)。按钮只对 `tab.markdown` 出现:非 Markdown
* 文档(代码 / 配置 / 纯文本)没有可渲染的语义。
*
* # 右键菜单
*
* - **关闭类**(当前 / 其他 / 左 / 右 / 全部)涉及脏数据确认,统一 `emit` 给
* `EditorWindow` 走既有确认流程;「关闭未修改」无脏数据风险,就地调用 store。
* - **位置 / 窗口类**(所在文件夹 / 资源管理器 / 新窗口 / 移动新窗口)只读 store 与系统;
* 其中「移动到新窗口」先落盘再开新窗口、最后关掉本标签。
* - **视图类**(并排分屏 / 固定)分别 `emit('split')` 与写 store。
* - **文件类**(重命名 / 复制名字 / 路径 / 相对路径)。
*
* # 拖拽重排与溢出下拉
*
* 标签支持 HTML5 拖拽重排(`store.moveTab`)。标签溢出横向滚动时,右侧出现下拉按钮,
* 汇总列出所有标签以便快速跳转 —— 否则藏在滚动区外的标签很难被发现。
*/
import { FileCode2, FileText, X } from '@lucide/vue'
import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import {
AppWindow,
ChevronDown,
ClipboardCopy,
Columns2,
Copy,
ExternalLink,
Eye,
FileCode2,
FileText,
FileX,
FolderOpen,
Pencil,
Pin,
PinOff,
X
} from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from '@/components/ui/dialog'
import { useEditorStore } from '@/stores/editorStore'
import { openEditorWindow } from '../openWindow'
const emit = defineEmits<{ close: [id: string] }>()
const props = defineProps<{
/** 正处于预览状态的标签 id(每个标签独立) */
previewIds: string[]
}>()
const emit = defineEmits<{
close: [id: string]
/** 切换某个标签的预览状态 */
'toggle-preview': [id: string]
'close-others': [id: string]
'close-left': [id: string]
'close-right': [id: string]
'close-all': []
/** 把某个标签放到副面板与当前文档并排 */
split: [id: string]
}>()
const store = useEditorStore()
const isPreviewing = (id: string) => props.previewIds.includes(id)
// ===== 标签的目标解析 =====
type Tab = (typeof store.tabs)[number]
function tabOf(id: string): Tab | undefined {
return store.tabs.find(t => t.id === id)
}
/** 标签对应文件的**真实文件名**(含扩展名;重命名对话框的初值)。 */
function tabFileName(id: string): string {
const tab = tabOf(id)
if (!tab) return ''
const source = tab.kind === 'note' ? tab.relPath : tab.path
return source.split(/[\\/]/).filter(Boolean).pop() ?? tab.name
}
/** 标签对应文件的**绝对路径**(复制 / 定位 / 打开所在文件夹用)。 */
function tabAbsPath(id: string): string {
const tab = tabOf(id)
if (!tab) return ''
if (tab.kind === 'note') return store.noteAbsPath(tab.relPath)
// 活动文件的真值在扁平 state 上,后台标签取收回的快照
return id === store.activeTabId ? (store.fileDoc?.path ?? tab.path) : tab.path
}
/** 标签对应文件的**相对路径**(仅库内笔记有意义)。 */
function tabRelPath(id: string): string {
const tab = tabOf(id)
return tab && tab.kind === 'note' ? tab.relPath : ''
}
// ===== 拖拽重排(Pointer Events)=====
//
// **为什么不用 HTML5 拖放**:编辑器窗口为了接收 OS 文件拖入而设了 `dragDropEnabled: true`
// (见 openWindow.ts),WebView2 的原生 OLE drop target 会拦截窗口内所有 HTML5 DnD ——
// `dragover` 的 `preventDefault()` 不生效,拖动时显示「禁止」光标。Pointer Events 不走
// 那条管线,与 Tauri 原生拖放零冲突(同侧栏宽度拖拽、结果面板高度拖拽的范式)。
const dragId = ref('')
const dragOverId = ref('')
/** 指针采集元素(releasePointerCapture 用) */
let dragEl: HTMLElement | null = null
/** 本次拖拽是否真的发生了重排:抑制紧随其后的 click,避免误激活 */
let reordered = false
function onTabPointerDown(id: string, event: PointerEvent): void {
if (event.button !== 0) return
// 点在预览 / 关闭按钮上时不启动拖拽(否则会与按钮的 click 抢指针)
if ((event.target as HTMLElement).closest('button')) return
dragEl = event.currentTarget as HTMLElement
dragId.value = id
dragOverId.value = ''
reordered = false
dragEl.setPointerCapture(event.pointerId)
window.addEventListener('pointermove', onTabPointerMove)
window.addEventListener('pointerup', onTabPointerUp)
window.addEventListener('pointercancel', onTabPointerUp)
}
function onTabPointerMove(event: PointerEvent): void {
if (!dragId.value) return
const over = (document.elementFromPoint(event.clientX, event.clientY) as HTMLElement | null)
?.closest<HTMLElement>('[data-tab-id]')
const overId = over?.dataset.tabId ?? ''
dragOverId.value = overId && overId !== dragId.value ? overId : ''
}
function onTabPointerUp(event: PointerEvent): void {
window.removeEventListener('pointermove', onTabPointerMove)
window.removeEventListener('pointerup', onTabPointerUp)
window.removeEventListener('pointercancel', onTabPointerUp)
try {
dragEl?.releasePointerCapture(event.pointerId)
} catch {
/* 指针已释放,忽略 */
}
dragEl = null
const from = dragId.value
const over = dragOverId.value
dragId.value = ''
dragOverId.value = ''
if (!from || !over || from === over) return
const to = store.tabs.findIndex(t => t.id === over)
if (to < 0) return
store.moveTab(from, to)
reordered = true
// click 在 pointerup 之后同批次派发;等它走完再复位
window.setTimeout(() => {
reordered = false
}, 0)
}
/** 标签点击:拖拽刚结束的那一下不再激活(否则拖完会顺带跳一下)。 */
function onTabClick(id: string): void {
if (reordered) return
store.activateTab(id)
}
// ===== 溢出下拉 =====
const stripRef = ref<HTMLElement | null>(null)
const overflowing = ref(false)
const overflowOpen = ref(false)
let resizeObserver: ResizeObserver | null = null
function updateOverflow(): void {
const el = stripRef.value
overflowing.value = !!el && el.scrollWidth > el.clientWidth + 1
if (!overflowing.value) overflowOpen.value = false
}
onMounted(() => {
if (stripRef.value) {
resizeObserver = new ResizeObserver(updateOverflow)
resizeObserver.observe(stripRef.value)
}
window.addEventListener('resize', updateOverflow)
void nextTick(updateOverflow)
})
onBeforeUnmount(() => {
resizeObserver?.disconnect()
resizeObserver = null
window.removeEventListener('resize', updateOverflow)
window.removeEventListener('pointermove', onTabPointerMove)
window.removeEventListener('pointerup', onTabPointerUp)
window.removeEventListener('pointercancel', onTabPointerUp)
})
// 标签数量 / 名称变化都可能改变宽度
watch(
() => store.tabViews.map(t => `${t.id}:${t.name}:${t.dirty}:${t.pinned}`).join('|'),
() => void nextTick(updateOverflow)
)
/** 从下拉列表切换标签:激活并把该标签滚进可视区。 */
function pickTab(id: string): void {
overflowOpen.value = false
store.activateTab(id)
void nextTick(() => {
stripRef.value?.querySelector(`[data-tab-id="${id}"]`)?.scrollIntoView({ inline: 'nearest', block: 'nearest' })
})
}
// ===== 右键菜单 =====
const menuOpen = ref(false)
const menuX = ref(0)
const menuY = ref(0)
/** 右键作用的标签 id(关闭菜单后仍保留,供重命名对话框使用) */
const menuTabId = ref('')
const MENU_WIDTH = 216
/** 菜单项行数(用于贴边翻转时预估高度:16 项 + 3 条分隔线) */
const MENU_HEIGHT = 16 * 28 + 3 * 9 + 16
const menuIndex = computed(() => store.tabs.findIndex(t => t.id === menuTabId.value))
const menuTab = computed(() => tabOf(menuTabId.value))
const hasLeft = computed(() => menuIndex.value > 0)
const hasRight = computed(() => menuIndex.value >= 0 && menuIndex.value < store.tabs.length - 1)
const hasOthers = computed(() => store.tabs.length > 1)
const hasUnmodified = computed(() =>
store.tabs.some(t => !t.pinned && !(t.id === store.activeTabId ? store.dirty : t.dirty))
)
function openMenu(event: MouseEvent, id: string): void {
menuTabId.value = id
menuX.value = Math.max(8, Math.min(event.clientX, window.innerWidth - MENU_WIDTH - 8))
menuY.value = Math.max(8, Math.min(event.clientY, window.innerHeight - MENU_HEIGHT - 8))
menuOpen.value = true
}
function closeMenu(): void {
menuOpen.value = false
}
/** 关闭菜单后执行(菜单是纯操作入口,不保留焦点)。 */
function run(action: () => void): void {
closeMenu()
action()
}
function openContainingFolder(): void {
const path = tabAbsPath(menuTabId.value)
const dir = path.slice(0, Math.max(path.lastIndexOf('\\'), path.lastIndexOf('/')))
if (!dir) {
toast.error('无法确定所在文件夹')
return
}
void store
.openFolder(dir)
.then(() => store.setSideView('directory'))
.catch(e => toast.error(`打开文件夹失败:${String(e)}`))
}
function revealInExplorer(): void {
const path = tabAbsPath(menuTabId.value)
if (path) store.revealPath(path)
}
async function openInNewWindow(): Promise<void> {
const tab = tabOf(menuTabId.value)
if (!tab) return
try {
if (tab.kind === 'note') await openEditorWindow({ relPath: tab.relPath, dedupe: false })
else await openEditorWindow({ path: tabAbsPath(tab.id), dedupe: false })
} catch (e) {
toast.error(`在新窗口打开失败:${String(e)}`)
}
}
/** 移动到新窗口:先落盘(保住未保存改动),再开新窗口,最后关掉本标签。 */
async function moveToNewWindow(): Promise<void> {
const id = menuTabId.value
const tab = tabOf(id)
if (!tab) return
try {
await store.saveTab(id)
} catch (e) {
toast.error(`保存失败,未移动:${String(e)}`)
return
}
try {
if (tab.kind === 'note') await openEditorWindow({ relPath: tab.relPath, dedupe: false })
else await openEditorWindow({ path: tabAbsPath(id), dedupe: false })
} catch (e) {
toast.error(`打开新窗口失败:${String(e)}`)
return
}
emit('close', id)
}
function togglePin(): void {
const tab = tabOf(menuTabId.value)
if (tab) store.setTabPinned(tab.id, !tab.pinned)
}
async function copyName(): Promise<void> {
const name = tabFileName(menuTabId.value)
if (!name) return
try {
await navigator.clipboard.writeText(name)
toast.success('已复制文件名')
} catch {
toast.error('复制失败')
}
}
async function copyPath(): Promise<void> {
const path = tabAbsPath(menuTabId.value)
if (!path) return
try {
await navigator.clipboard.writeText(path)
toast.success('已复制文件路径')
} catch {
toast.error('复制失败')
}
}
async function copyRelPath(): Promise<void> {
const rel = tabRelPath(menuTabId.value)
if (!rel) return
try {
await navigator.clipboard.writeText(rel)
toast.success('已复制相对路径')
} catch {
toast.error('复制失败')
}
}
// ===== 重命名 =====
const renameOpen = ref(false)
const renameValue = ref('')
const renameBusy = ref(false)
function startRename(): void {
renameValue.value = tabFileName(menuTabId.value)
renameOpen.value = true
}
async function confirmRename(): Promise<void> {
const name = renameValue.value.trim()
if (!name) {
toast.error('名称不能为空')
return
}
renameBusy.value = true
try {
await store.renameTab(menuTabId.value, name)
renameOpen.value = false
} catch (e) {
toast.error(String(e))
} finally {
renameBusy.value = false
}
}
</script>
<template>
<div class="flex h-8 shrink-0 items-stretch gap-0.5 overflow-x-auto border-b border-border px-1">
<div
v-for="tab in store.tabViews"
:key="tab.id"
class="group flex max-w-52 min-w-0 cursor-pointer items-center gap-1.5 rounded-t-sm border-b-2 px-2 text-xs transition-colors duration-150"
:class="
tab.id === store.activeTabId
? 'border-primary bg-row-selected text-foreground'
: 'border-transparent text-fg-secondary hover:bg-row-hover hover:text-foreground'
"
:title="tab.name"
@click="store.activateTab(tab.id)"
<div class="relative flex h-8 shrink-0 items-stretch border-b border-border">
<div ref="stripRef" class="flex min-w-0 flex-1 items-stretch gap-0.5 overflow-x-auto px-1">
<div
v-for="tab in store.tabViews"
:key="tab.id"
:data-tab-id="tab.id"
class="group flex max-w-52 min-w-0 cursor-pointer items-center gap-1.5 rounded-t-sm border-b-2 px-2 text-xs transition-colors duration-150"
:class="[
tab.id === store.activeTabId
? 'border-primary bg-row-selected text-foreground'
: 'border-transparent text-fg-secondary hover:bg-row-hover hover:text-foreground',
dragId === tab.id && 'opacity-40',
dragOverId === tab.id && 'ring-1 ring-primary ring-inset'
]"
:title="tab.name"
@pointerdown="onTabPointerDown(tab.id, $event)"
@click="onTabClick(tab.id)"
@contextmenu.prevent="openMenu($event, tab.id)"
>
<Pin v-if="tab.pinned" class="size-3 shrink-0 text-primary" title="已固定" />
<FileText v-if="tab.kind === 'note'" class="size-3.5 shrink-0 opacity-70" />
<FileCode2 v-else class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ tab.name }}</span>
<span v-if="tab.dirty" class="shrink-0 font-medium text-primary" title="有未保存的改动">*</span>
<!-- 预览:仅 Markdown 标签出现;**常驻可见**(不做 hover 才显形,否则用户不知道有这个能力) -->
<button
v-if="tab.markdown"
type="button"
class="shrink-0 rounded-sm p-0.5 transition-colors hover:bg-active"
:class="isPreviewing(tab.id) ? 'bg-active text-primary' : 'text-muted-foreground hover:text-foreground'"
:title="isPreviewing(tab.id) ? '退出预览,回到编辑器' : '预览渲染后的 Markdown'"
@click.stop="emit('toggle-preview', tab.id)"
>
<Eye class="size-3" />
</button>
<button
type="button"
class="shrink-0 rounded-sm p-0.5 opacity-0 transition-opacity hover:bg-active group-hover:opacity-100"
title="关闭标签(Ctrl+W)"
@click.stop="emit('close', tab.id)"
>
<X class="size-3" />
</button>
</div>
</div>
<!-- 溢出下拉:标签太多时汇总列出,避免藏在滚动区外 -->
<button
v-if="overflowing"
type="button"
class="flex shrink-0 items-center px-1 text-muted-foreground transition-colors hover:bg-row-hover hover:text-foreground"
title="全部标签"
@click="overflowOpen = !overflowOpen"
>
<ChevronDown class="size-3.5" />
</button>
<template v-if="overflowOpen">
<div class="fixed inset-0 z-40" @click="overflowOpen = false" />
<div
class="absolute top-full right-0 z-50 max-h-72 w-64 overflow-y-auto rounded-md border border-border bg-card py-1 text-xs shadow-md"
>
<button
v-for="tab in store.tabViews"
:key="tab.id"
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
:class="tab.id === store.activeTabId ? 'text-foreground' : 'text-fg-secondary'"
@click="pickTab(tab.id)"
>
<Pin v-if="tab.pinned" class="size-3 shrink-0 text-primary" />
<FileText v-if="tab.kind === 'note'" class="size-3.5 shrink-0 opacity-70" />
<FileCode2 v-else class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ tab.name }}</span>
<span v-if="tab.dirty" class="shrink-0 font-medium text-primary">*</span>
</button>
</div>
</template>
</div>
<!-- 右键菜单 -->
<template v-if="menuOpen">
<div class="fixed inset-0 z-40" @click="closeMenu" @contextmenu.prevent="closeMenu" />
<div
class="fixed z-50 min-w-[216px] overflow-hidden rounded-md border border-border bg-card py-1 text-xs text-foreground shadow-md"
:style="{ left: `${menuX}px`, top: `${menuY}px` }"
>
<FileText v-if="tab.kind === 'note'" class="size-3.5 shrink-0 opacity-70" />
<FileCode2 v-else class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ tab.name }}</span>
<span v-if="tab.dirty" class="shrink-0 font-medium text-primary" title="有未保存的改动">*</span>
<button
type="button"
class="shrink-0 rounded-sm p-0.5 opacity-0 transition-opacity hover:bg-active group-hover:opacity-100"
title="关闭标签(Ctrl+W)"
@click.stop="emit('close', tab.id)"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(() => emit('close', menuTabId))"
>
<X class="size-3" />
<X class="size-3.5 opacity-70" />关闭当前文件
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="!hasOthers"
@click="run(() => emit('close-others', menuTabId))"
>
<X class="size-3.5 opacity-70" />关闭其他文件
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="!hasLeft"
@click="run(() => emit('close-left', menuTabId))"
>
<X class="size-3.5 opacity-70" />关闭左边所有
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="!hasRight"
@click="run(() => emit('close-right', menuTabId))"
>
<X class="size-3.5 opacity-70" />关闭右边所有
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(() => emit('close-all'))"
>
<X class="size-3.5 opacity-70" />关闭所有文件
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="!hasUnmodified"
@click="run(() => store.closeUnmodifiedTabs())"
>
<FileX class="size-3.5 opacity-70" />关闭未修改标签
</button>
<div class="my-1 h-px bg-divider" />
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(openContainingFolder)"
>
<FolderOpen class="size-3.5 opacity-70" />打开所在文件夹
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(revealInExplorer)"
>
<ExternalLink class="size-3.5 opacity-70" />在资源管理器打开
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(openInNewWindow)"
>
<AppWindow class="size-3.5 opacity-70" />在新窗口打开
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(moveToNewWindow)"
>
<AppWindow class="size-3.5 opacity-70" />移动到新窗口
</button>
<div class="my-1 h-px bg-divider" />
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="menuTabId === store.activeTabId"
@click="run(() => emit('split', menuTabId))"
>
<Columns2 class="size-3.5 opacity-70" />并排分屏
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(togglePin)"
>
<PinOff v-if="menuTab?.pinned" class="size-3.5 opacity-70" />
<Pin v-else class="size-3.5 opacity-70" />
{{ menuTab?.pinned ? '取消固定' : '固定标签' }}
</button>
<div class="my-1 h-px bg-divider" />
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(startRename)"
>
<Pencil class="size-3.5 opacity-70" />重命名文件
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(copyName)"
>
<Copy class="size-3.5 opacity-70" />复制文件名
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover"
@click="run(copyPath)"
>
<ClipboardCopy class="size-3.5 opacity-70" />复制文件路径
</button>
<button
type="button"
class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left transition-colors hover:bg-row-hover disabled:pointer-events-none disabled:opacity-40"
:disabled="menuTab?.kind !== 'note'"
@click="run(copyRelPath)"
>
<Copy class="size-3.5 opacity-70" />复制相对路径
</button>
</div>
</div>
</template>
</template>
<!-- 重命名文件 -->
<Dialog :open="renameOpen" @update:open="renameOpen = $event">
<DialogContent class="sm:max-w-sm">
<DialogHeader>
<DialogTitle>重命名文件</DialogTitle>
</DialogHeader>
<Input v-model="renameValue" placeholder="文件名(含扩展名)" @keydown.enter="confirmRename" />
<DialogFooter>
<Button variant="outline" :disabled="renameBusy" @click="renameOpen = false">取消</Button>
<Button :disabled="renameBusy" @click="confirmRename">确定</Button>
</DialogFooter>
</DialogContent>
</Dialog>
</template>
+30 -10
View File
@@ -88,31 +88,44 @@ function isActive(view: SideView): boolean {
}
/**
* 导出当前笔记为 HTML。
* 导出当前 Markdown 文档为 HTML(笔记与库外 `.md` 文件都支持)。
*
* 两条落盘路径,因为两者的「真相位置」不同:
* - **笔记**:走库语义 `exportNote`(库内相对路径,磁盘上的那一份为准);
* - **库外文件**:目标路径来自系统对话框,先 `authorizeFile` 再 `writeFile`
* (文件的写入是严格的:没登记过的路径一律拒绝)。
*
* 渲染链路(markdown-it + DOMPurify + highlight.js)**按需 import**:
* 它约 1MB,而导出是低频动作 —— 静态引入会让「打开编辑器窗口」这个最常见的动作
* 也背上这份体积。
*/
async function exportHtml(): Promise<void> {
if (!store.currentRelPath) return
if (!store.hasDocument) return
const isNote = store.kind === 'note'
const relPath = store.currentRelPath
if (isNote && !relPath) return
exporting.value = true
try {
const doc = await editorClient.readNote(store.currentRelPath)
const doc = isNote
? await editorClient.readNote(relPath)
: { name: store.fileDoc?.name ?? 'document.md', content: store.content }
const base = doc.name.replace(/\.(md|markdown|mdx)$/i, '')
const { renderNoteHtml } = await import('../editor/markdownExport')
const html = renderNoteHtml({
title: store.currentName || doc.name.replace(/\.md$/i, ''),
title: (isNote && store.currentName) || base,
fileName: doc.name,
markdown: doc.content,
highlight: store.settings.exportHighlight
})
const dest = await open({
title: '导出为 HTML',
defaultPath: `${doc.name.replace(/\.md$/i, '')}.html`,
defaultPath: `${base}.html`,
filters: [{ name: 'HTML 文件', extensions: ['html'] }]
})
if (typeof dest !== 'string') return
const saved = await editorClient.exportNote(store.currentRelPath, html, dest)
const saved = isNote
? await editorClient.exportNote(relPath, html, dest)
: await writeExternalHtml(dest, html)
toast.success(`已导出:${saved}`)
} catch (e) {
toast.error(`导出失败:${String(e)}`)
@@ -120,6 +133,13 @@ async function exportHtml(): Promise<void> {
exporting.value = false
}
}
/** 库外文件的导出落盘:先登记授权(路径来自系统对话框),再按 UTF-8 写入。 */
async function writeExternalHtml(dest: string, html: string): Promise<string> {
await editorClient.authorizeFile(dest)
await editorClient.writeFile(dest, html, 'utf-8', 'lf')
return dest
}
</script>
<template>
@@ -202,8 +222,9 @@ async function exportHtml(): Promise<void> {
<Loader2 v-if="saving" class="size-3.5 animate-spin" />
<Save v-else class="size-3.5" />
</Button>
<!-- 视图切换 / 导出 / 格式化:只对 Markdown 有意义(笔记与库外 .md 文件同样开放) -->
<Button
v-if="store.kind === 'note'"
v-if="store.isMarkdown"
variant="ghost"
size="icon-sm"
:title="viewMode === 'wysiwyg' ? '切到源码视图 (Ctrl+Shift+M)' : '切到所见即所得 (Ctrl+Shift+M)'"
@@ -212,7 +233,7 @@ async function exportHtml(): Promise<void> {
<Eye class="size-3.5" />
</Button>
<Button
v-if="store.kind === 'note' && store.currentRelPath"
v-if="store.isMarkdown"
variant="ghost"
size="icon-sm"
:disabled="exporting"
@@ -223,8 +244,7 @@ async function exportHtml(): Promise<void> {
<FileDown v-else class="size-3.5" />
</Button>
<!-- Markdown 格式化(仅笔记) -->
<template v-if="store.kind === 'note'">
<template v-if="store.isMarkdown">
<div class="mx-1 h-4 w-px shrink-0 bg-divider" />
<Button variant="ghost" size="icon-sm" title="加粗 (Ctrl+B)" @click="run(editorCommands.bold)">
<Bold class="size-3.5" />
+1 -1
View File
@@ -132,7 +132,7 @@ watch(keyword, () => {
>
<div
ref="panelRef"
class="flex max-h-[60vh] w-[min(560px,92vw)] flex-col overflow-hidden rounded-lg border border-border bg-popup shadow-lg"
class="flex max-h-[60vh] w-[min(560px,92vw)] flex-col overflow-hidden rounded-lg border border-border bg-popover text-popover-foreground shadow-lg"
@keydown="onKeydown"
>
<div class="relative shrink-0 border-b border-border p-2">
+25 -2
View File
@@ -22,6 +22,25 @@ const store = useEditorStore()
const files = computed(() => store.recentFiles)
const folders = computed(() => store.recentFolders)
/** 取所在目录(同时兼容 `\` 与 `/`)。 */
function parentDir(fullPath: string): string {
const index = Math.max(fullPath.lastIndexOf('\\'), fullPath.lastIndexOf('/'))
return index > 0 ? fullPath.slice(0, index) : ''
}
/**
* 路径尾部摘要:只保留末尾若干字符并前置省略号(例:`...ways\Downloads`)。
*
* 做「一眼看出在哪儿」的提示,完整路径仍由行的 `title` 提供。短路径整段显示,
* 长路径保留末尾 14 个字符 —— 前面的盘符与中间层级对辨认位置帮助不大,省略它们
* 反而让列表更整齐。目录项与文件项都取**所在目录**,名字里已经有的末级不再重复。
*/
function pathTail(fullPath: string): string {
const dir = parentDir(fullPath).replace(/\//g, '\\')
if (!dir) return ''
return dir.length <= 18 ? dir : `...${dir.slice(-14)}`
}
async function openFile(entry: RecentEntry): Promise<void> {
try {
await store.openDoc(entry.path)
@@ -83,7 +102,9 @@ async function openFolder(entry: RecentEntry): Promise<void> {
@click="openFile(entry)"
>
<FileText class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ entry.name }}</span>
<span class="truncate">
{{ entry.name }}<span v-if="pathTail(entry.path)" class="text-muted-foreground">({{ pathTail(entry.path) }})</span>
</span>
<span v-if="!entry.exists" class="shrink-0 text-[10px]">(已失效)</span>
<button
type="button"
@@ -118,7 +139,9 @@ async function openFolder(entry: RecentEntry): Promise<void> {
@click="openFolder(entry)"
>
<History class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ entry.name }}</span>
<span class="truncate">
{{ entry.name }}<span v-if="pathTail(entry.path)" class="text-muted-foreground">({{ pathTail(entry.path) }})</span>
</span>
<span v-if="!entry.exists" class="shrink-0 text-[10px]">(已失效)</span>
<button
type="button"
@@ -52,18 +52,16 @@ const inputRef = ref<InstanceType<typeof Input> | null>(null)
const manualOpen = ref(false)
/**
* 只在「输入框有内容」时按包含关系过滤,空框则列全部。
* 历史条目(新的在前)。
*
* 当前值本身要从列表里排除(否则刚提交过的词会自己冒出来挡着)。
* **不按当前输入过滤**:早先按包含关系筛过一遍 —— 一旦输入框里的词不是任何历史项的子串
* (例如刚敲进去一个没搜过的词),下拉会被判定为空,点历史图标就毫无反应;而「翻出之前
* 搜过什么」恰恰是那一刻的需求。故始终列出**完整历史**,点一下就能看到全部用过的值。
*/
const items = computed(() => {
const query = props.modelValue.trim().toLowerCase()
const list = props.history.filter(h => h !== props.modelValue)
if (!query) return list
return list.filter(h => h.toLowerCase().includes(query))
})
const items = computed(() => props.history)
const open = computed(() => manualOpen.value && !props.disabled && items.value.length > 0)
/** 历史图标点击即可展开 —— 与输入框当前内容无关,随时可唤出。 */
const open = computed(() => manualOpen.value && !props.disabled)
function toggleHistory(): void {
manualOpen.value = !open.value
@@ -73,13 +71,18 @@ function closeHistory(): void {
manualOpen.value = false
}
/** 聚焦输入框(不动内容与选区;用于「把焦点放回查找框」)。 */
function focus(): void {
inputRef.value?.focus()
}
/** 聚焦并全选已有内容(打开卡片时用:直接输入即可覆盖)。 */
function focusAndSelect(): void {
inputRef.value?.focus()
inputRef.value?.element()?.select()
}
defineExpose({ focusAndSelect })
defineExpose({ focus, focusAndSelect })
</script>
<template>
@@ -120,6 +123,7 @@ defineExpose({ focusAndSelect })
<div class="flex items-center gap-1 px-1.5 py-1 text-[10px] text-fg-disabled">
<History class="size-3" />历史
<button
v-if="items.length"
type="button"
class="ml-auto rounded-sm px-1 transition-colors duration-150 hover:bg-hover hover:text-foreground"
title="清空这组历史"
@@ -129,7 +133,10 @@ defineExpose({ focusAndSelect })
</button>
</div>
<ScrollArea class="max-h-56">
<!-- 无历史时也要给一句说明:图标随时可点开,空下拉不能是一片空白 -->
<p v-if="!items.length" class="px-1.5 py-1 text-[11px] text-fg-disabled">暂无历史</p>
<ScrollArea v-else class="max-h-56">
<div class="pb-0.5">
<div
v-for="item in items"
+164
View File
@@ -0,0 +1,164 @@
/**
* Windows 批处理(`.bat` / `.cmd`)的流式语法。
*
* # 为什么要自建
*
* CM6 没有 batch 语言包(不存在 `@codemirror/lang-batch`),`@codemirror/legacy-modes`
* 也没有对应的流式模式 —— 官方 `@codemirror/language-data` 同样给不出 `.bat` 的高亮。
* 因此这里补一个**最简可用**的词法器,走与其它语言相同的 `StreamLanguage` 通道
* (同 `aspMode.ts` 的定位)。
*
* # 为什么是词法而不是语法树
*
* 批处理本来就不是「先解析再高亮」的语言:命令、参数、重定向都是**行**层面的约定,
* 没有可供 lezer 依靠的语句结构。逐行词法已经能覆盖绝大多数观感需求 —— 注释、标签、
* 变量、字符串、命令、重定向与分隔符。代价是没有语义标签,也不提供补全。
*
* # 已知取舍(诚实记录,未做未提)
*
* - 命令只在**语句起始处**着色(行首 / `(` / `)` / `&` / `&&` / `|` / `||` / `do` /
* `else` 之后)。若全文档按词着色,路径与变量值里的同名单词(`C:\Git\cmd`、
* `set x=echo`)会被误判成命令,那属于「高亮错乱」,比不上色更糟;
* - 由此带来的缺口:`if … goto …` 里 `if` 之后的命令不在语句起始处,不会着色;
* - `REM` 只认**语句起始处**的写法(`& rem x` 这种行内注释不额外处理);
* - 字符串不处理 `^` 转义(`"a^"b"` 这种极端写法会提前收尾)。
*/
import { StreamLanguage, type StreamParser, type StringStream } from '@codemirror/language'
import type { Extension } from '@codemirror/state'
/** 词法状态:下一个词是否处在语句起始处(决定要不要按「命令」着色)。 */
interface BatchState {
stmtStart: boolean
}
/**
* 命令 / 关键字的词法白名单(小写)。
*
* 做成集合而不是正则:命令是确定的一小组词,命中即命令,未命中按普通词处理。
* `rem` 不列在这里 —— 它在语句起始处由上面的注释分支先行拦下。
*/
const COMMANDS = new Set<string>([
'assoc', 'attrib', 'break', 'call', 'cd', 'chdir', 'chkdsk', 'choice', 'cls', 'cmd',
'color', 'comp', 'copy', 'date', 'defined', 'del', 'dir', 'do', 'echo', 'else',
'endlocal', 'erase', 'errorlevel', 'exist', 'exit', 'fc', 'find', 'findstr', 'for',
'format', 'ftype', 'goto', 'help', 'if', 'in', 'ipconfig', 'label', 'md', 'mkdir',
'mode', 'more', 'move', 'net', 'netstat', 'not', 'path', 'pause', 'ping', 'popd',
'print', 'prompt', 'pushd', 'rd', 'recover', 'reg', 'ren', 'rename', 'replace',
'rmdir', 'robocopy', 'route', 'sc', 'schtasks', 'set', 'setlocal', 'shift', 'sort',
'start', 'subst', 'systeminfo', 'taskkill', 'tasklist', 'time', 'timeout', 'title',
'tracert', 'tree', 'type', 'ver', 'verify', 'vol', 'where', 'wmic', 'xcopy',
// setlocal 的子命令
'enableextensions', 'enabledelayedexpansion', 'disabledelayedexpansion'
])
/** 需要在命令之后把「语句起始处」重新打开的写法(`for … do echo …` / `) else (`)。 */
const COMMAND_OPENERS = new Set(['do', 'else'])
function createBatch(): StreamParser<BatchState> {
return {
name: 'batch',
startState: () => ({ stmtStart: true }),
copyState: state => ({ stmtStart: state.stmtStart }),
blankLine: state => {
state.stmtStart = true
},
token(stream: StringStream, state: BatchState) {
// 每个新行都从「语句起始处」开始(sol 只在本行第一次调用时为真)
if (stream.sol()) state.stmtStart = true
if (stream.eatSpace()) return null
// ===== 语句起始处:注释 / 标签 / 命令 =====
if (state.stmtStart) {
// `::` 注释(批处理里 `::` 常被当作注释写法)
if (stream.match('::')) {
stream.skipToEnd()
return 'comment'
}
// `REM` / `@REM` 行注释(词边界,避免把 `remark` 当成注释)
if (stream.match(/^@?rem\b/i)) {
stream.skipToEnd()
return 'comment'
}
// `:label`
if (stream.match(/^:[A-Za-z_][\w.-]*/)) {
state.stmtStart = false
return 'labelName'
}
// `@`(关闭回显,如 `@echo off`)—— 后面的词仍算语句起始处,故不重置 stmtStart
if (stream.eat('@')) return 'meta'
// 命令词:命中白名单才着色,未命中按普通词处理
const word = stream.match(/^[A-Za-z]+/) as RegExpMatchArray | null
if (word) {
const lower = word[0].toLowerCase()
if (COMMANDS.has(lower)) {
state.stmtStart = COMMAND_OPENERS.has(lower)
return 'keyword'
}
state.stmtStart = false
return null
}
}
// 走到这里说明本词不是「语句起始处的命令形态」(变量 / 字符串 / 运算符 / 数字…)
state.stmtStart = false
// ===== 字符串(未闭合则吃到行尾) =====
if (stream.eat('"')) {
stream.eatWhile(ch => ch !== '"')
stream.eat('"')
return 'string'
}
// ===== 变量 =====
// `%%i`(for 的循环变量)/ `%%~ni`
if (stream.match(/^%%~?[A-Za-z]+/)) return 'variable-2'
// `!VAR!`(延迟展开)
if (stream.match(/^![A-Za-z0-9_]+!/)) return 'variable-2'
// `%VAR%`(环境变量,如 `%ERRORLEVEL%`、`%PATH%`)
if (stream.match(/^%[A-Za-z_][A-Za-z0-9_]*%/)) return 'variable'
// `%1` / `%~1` / `%*` / `%~dp0`(位置参数与修饰)
if (stream.match(/^%~?[A-Za-z0-9*]+/)) return 'variable'
// ===== 重定向:`>` / `>>` / `2>` / `<` =====
if (stream.match(/^\d*>>?|^\d*</)) return 'operator'
// ===== 语句分隔 / 管道(其后的词回到语句起始处) =====
if (stream.match('&&') || stream.match('||')) {
state.stmtStart = true
return 'operator'
}
if (stream.eat('&') || stream.eat('|')) {
state.stmtStart = true
return 'operator'
}
// ===== 比较(`if "%a%"=="%b%"`) =====
if (stream.match('==')) return 'operator'
// ===== 分组括号(块内的词仍是语句起始处) =====
if (stream.eat('(') || stream.eat(')')) {
state.stmtStart = true
return 'punctuation'
}
// ===== 数字 =====
if (stream.match(/^\d+/)) return 'number'
// ===== 普通词 / 路径:整段吞掉,不上色 =====
// 逐字符着色会让长路径产生海量 token(`readToken` 每次只走一个 token),
// 这里把连续的非结构字符一次性吃掉,兼顾性能与「不误判」。
if (stream.match(/^[^\s&|<>()"'%!^@=]+/)) return null
// 兜底:保证流一定前进(防止 `readToken` 因零位移报错)
stream.next()
return null
}
}
}
/** Windows 批处理(`.bat` / `.cmd`)的流式语言扩展。 */
export function batch(): Extension {
return StreamLanguage.define(createBatch())
}
+1 -1
View File
@@ -59,7 +59,7 @@ export interface EditorConfig {
ligatures: boolean
theme: string
followAppTheme: boolean
/** 应用当前是否为深色(跟随应用时用于取深/浅变体) */
/** 编辑器**窗口**当前的深浅(由 EditorWindow 按「跟随主应用主题 / 配色方案」推导) */
isDark: boolean
/** 语言扩展加载器 */
language: LanguageLoader
+66
View File
@@ -4,6 +4,7 @@
* 命令都通过 `state.changeByRange` 表达,保证多光标下每个选区都被正确处理。
*/
import { EditorSelection, type EditorState } from '@codemirror/state'
import { ensureSyntaxTree, syntaxTree } from '@codemirror/language'
import { type Command, type KeyBinding } from '@codemirror/view'
/** 用标记包裹选区;若选区两侧已是该标记,则取消包裹(可反复切换)。 */
@@ -105,8 +106,73 @@ const insertCodeBlock: Command = view => {
return true
}
/**
* 光标处是否是一个**未闭合**的围栏开头。
*
* 用语法树而不是纯文本判断,是为了区分三种长得很像的情况:
*
* - 真的刚起了个头(``` 或 ```ts 独占一行,节点止于本行)→ 是;
* - 已经写完了(节点一直延伸到后面的闭合围栏)→ 否,否则会把整块内容挤到尾巴后面;
* - 光标停在**闭合**围栏上(节点起点在更早的行)→ 否。
*
* 顺带一提:非 Markdown 文档(`.ts` 里的模板字符串等)本来就没有 `FencedCode` 节点,
* 因此这个判断天然把补全限定在了 Markdown 里,不需要额外的文件类型分支。
*
* `ensureSyntaxTree` 会强制同步解析到这里 —— 用户敲完 ``` 立刻按回车时,增量解析可能
* 还没追上最后一次输入,直接读 `syntaxTree` 会拿到还没有这个围栏的旧树。
*/
function isUnclosedFenceAt(state: EditorState, lineFrom: number, lineTo: number): boolean {
const tree = ensureSyntaxTree(state, lineTo, 100) ?? syntaxTree(state)
let unclosed = false
tree.iterate({
from: lineFrom,
to: lineTo,
enter: node => {
if (node.name !== 'FencedCode') return
// 起点在本行 = 这是开头围栏;终点不越过本行 = 还没闭合
if (node.from >= lineFrom && node.to <= lineTo) unclosed = true
return false
}
})
return unclosed
}
/**
* 围栏代码块「自动补尾巴」:光标停在 ``` / ```ts 这类未闭合的开头上按回车,补出闭合
* 围栏,并把光标留在中间那行(空行):
*
* ```ts
* <光标>
* ```
*
* 只在**光标位于行尾**时触发:光标在行中按回车应当是「拆行」这个默认行为,硬插尾巴只会
* 把后半截挤到围栏之外。
*/
const insertFenceTail: Command = view => {
const { state } = view
const range = state.selection.main
if (!range.empty) return false
const line = state.doc.lineAt(range.head)
if (range.head !== line.to) return false
const match = /^(\s*)(`{3,}|~{3,})\s*([^\s`~]*)\s*$/.exec(line.text)
if (!match) return false
if (!isUnclosedFenceAt(state, line.from, line.to)) return false
const [, indent, fence] = match
view.dispatch({
changes: { from: range.head, insert: `\n\n${indent}${fence}` },
// 落在中间的空行上,用户直接开写正文
selection: EditorSelection.cursor(range.head + 1),
userEvent: 'input'
})
return true
}
/** 编辑器快捷键(优先级高于全局快捷键)。 */
export const editorKeymap: KeyBinding[] = [
// 回车补围栏尾巴:必须排在 `defaultKeymap` 的 Enter 之前才轮得到(见 core.ts 的装配顺序)
{ key: 'Enter', run: insertFenceTail, preventDefault: true },
{ key: 'Mod-b', run: wrapSelection('**'), preventDefault: true },
{ key: 'Mod-i', run: wrapSelection('*'), preventDefault: true },
{ key: 'Mod-Shift-x', run: wrapSelection('~~'), preventDefault: true },
+20
View File
@@ -117,6 +117,18 @@ const MAKEFILE: LanguageEntry = {
load: () => import('codemirror-lang-makefile').then(m => m.makefile())
}
/**
* Markdown(`.md` / `.markdown` / `.mdx`)。
*
* 笔记(`kind: 'note'`)走 `markdownLoader()` 的专用通道,但**库外文件**(「打开文件」
* 或拖入的外部 `.md`)走的是下面的 `LOADERS` 表 —— 此前漏登记,于是这类 `.md` 被当作
* 「纯文本」,既无 markdown 高亮、状态栏也显示纯文本。
*/
const MARKDOWN: LanguageEntry = {
label: 'Markdown',
load: () => markdownLoader()()
}
/**
* 扩展名(小写,不含点)→ 语言。
*
@@ -124,6 +136,10 @@ const MAKEFILE: LanguageEntry = {
* 表本身的构建不产生任何网络/打包开销。
*/
const LOADERS: Record<string, LanguageEntry> = {
// ===== 标记 / 文档 =====
md: MARKDOWN,
markdown: MARKDOWN,
mdx: MARKDOWN,
// ===== 前端 =====
js: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
mjs: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
@@ -232,6 +248,10 @@ const LOADERS: Record<string, LanguageEntry> = {
label: 'PowerShell',
load: () => stream(() => import('@codemirror/legacy-modes/mode/powershell'), m => m.powerShell)
},
// Windows 批处理(`.bat` / `.cmd`):CM6 与 legacy-modes 都没有对应模式,
// 自建一个流式词法器,见 `batchMode.ts`
bat: { label: 'Batch', load: () => import('./batchMode').then(m => m.batch()) },
cmd: { label: 'Batch', load: () => import('./batchMode').then(m => m.batch()) },
// VBScript / VB.NET(与 ASP 同族,但独立文件按纯脚本高亮,不套 HTML 多路复用)。
// VBScript 用裹了一层词法修正的 vbScript(原版把语句分隔符 `:` 当 error 涂红)——
// 见 `vbsStream()` 注释;ASP 的多路复用内部复用了同一个修正版
@@ -271,7 +271,7 @@ function createBuilder(options: LivePreviewOptions) {
if (!active) hide(node.from, node.to, true)
break
case 'CodeMark':
// 仅行内代码的反引号隐藏;围栏代码块的 ``` 保留(保留语言标注)
// 行内代码的反引号;围栏代码块的 ``` 连同语言标注在 FencedCode 分支里整行处理
if (!active && n.parent?.name === 'InlineCode') hide(node.from, node.to)
break
@@ -294,12 +294,37 @@ function createBuilder(options: LivePreviewOptions) {
break
}
// ===== 围栏代码块:整块底色 =====
// ===== 围栏代码块:整块底色 + 围栏行隐藏 =====
case 'FencedCode': {
// 开头的 ``` 永远是第一个子节点;结尾的 ``` 只有在**闭合**时才存在
// (未闭合时最后一个子节点是代码正文),据此拿到两条围栏各自所在的行
const openMark = n.firstChild?.name === 'CodeMark' ? n.firstChild : null
const closeMark =
n.lastChild?.name === 'CodeMark' && n.lastChild !== openMark ? n.lastChild : null
const openLine = openMark ? doc.lineAt(openMark.from).number : -1
const closeLine = closeMark ? doc.lineAt(closeMark.from).number : -1
const firstLine = doc.lineAt(node.from).number
const lastLine = doc.lineAt(node.to).number
let pos = node.from
while (pos <= node.to) {
const l = doc.lineAt(pos)
line(l.from, 'cm-md-codeblock')
const classes = ['cm-md-codeblock']
if (l.number === firstLine) classes.push('cm-md-codeblock-first')
if (l.number === lastLine) classes.push('cm-md-codeblock-last')
decos.push({
from: l.from,
to: l.from,
value: Decoration.line({ class: classes.join(' ') })
})
// 围栏行(开头的 ``` / ```lang 与结尾的 ```)整行隐藏 —— Obsidian 的做法:
// 只有光标落到那一行,语法符号才显形。隐藏后该行留空,正好当作代码区的留白
// (光标在块内任意正文行时,上下围栏都不会跳出来打断阅读)。
if ((l.number === openLine || l.number === closeLine) && !isActive(l.from)) {
hide(l.from, l.to)
}
if (l.to >= node.to) break
pos = l.to + 1
}
@@ -385,8 +410,21 @@ const livePreviewTheme = EditorView.baseTheme({
opacity: '0.9',
paddingLeft: '12px'
},
// 围栏代码块:一块**独立的输入区**(底色 + 圆角 + 代码字体 + 左右留白),
// 围栏符号本身由上层装饰在非光标行隐藏,于是看到的只有代码本身
'.cm-md-codeblock': {
backgroundColor: 'rgba(127, 127, 127, 0.12)'
backgroundColor: 'rgba(127, 127, 127, 0.12)',
paddingLeft: '12px',
paddingRight: '12px',
fontFamily: "'Cascadia Code', 'JetBrains Mono', Consolas, monospace"
},
'.cm-md-codeblock-first': {
borderTopLeftRadius: '8px',
borderTopRightRadius: '8px'
},
'.cm-md-codeblock-last': {
borderBottomLeftRadius: '8px',
borderBottomRightRadius: '8px'
},
'.cm-md-inlinecode': {
backgroundColor: 'rgba(127, 127, 127, 0.16)',
+62 -29
View File
@@ -23,7 +23,7 @@ import { oneDark } from '@codemirror/theme-one-dark'
import { createTheme } from '@uiw/codemirror-themes'
import { tags as t } from '@lezer/highlight'
/** 主题的亮暗归属(供「跟随应用」取对应侧) */
/** 主题的亮暗归属(「跟随主应用主题」关闭时,窗口外壳与编辑区都按它取深浅) */
interface ThemeDefinition {
dark: boolean
extension: Extension
@@ -197,7 +197,31 @@ const MONOKAI_PRO: TagStyle[] = [
{ tag: t.quote, color: '#727072' }
]
/** 主题注册表(key 与 Rust 侧取值一致) */
/**
* `one-dark` 的高亮覆盖层。
*
* 其它主题都走 `createTheme`,选中 / 活动行由各自的 `settings` 直接给色;而 `one-dark`
* 用的是现成扩展 `oneDark`,这几处配色是它内置的、改不到。这里追加一层覆盖主题把它们
* 提到与其它主题一致的对比度(活动行 `<lineHighlight>`、选中 `<selection>`、同词匹配
* `<selectionMatch>`)。选择器与 oneDark 内置的一致并加 `!important`,确保覆盖生效。
*/
const ONE_DARK_HIGHLIGHT: Extension = EditorView.theme(
{
'&.cm-focused .cm-selectionBackground, & .cm-selectionLayer .cm-selectionBackground, .cm-content ::selection':
{ background: '#4a5670 !important' },
'.cm-selectionMatch': { backgroundColor: '#4a5670b3 !important' },
'.cm-activeLine': { backgroundColor: '#ffffff1a !important' }
},
{ dark: true }
)
/**
* 主题注册表(key 与 Rust 侧取值一致)。
*
* 每套主题的 `selection` / `selectionMatch` / `lineHighlight` 都**刻意调高对比度**:
* 活动行、选中文字、同词匹配若照搬上游的浅色值(例如 VS Code 的 `#264f78`、
* `#ffffff0a`),在编辑器里几乎看不出选中范围。宁可略重也不要看不清。
*/
export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
'vscode-dark': {
dark: true,
@@ -207,9 +231,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#1e1e1e',
foreground: '#d4d4d4',
caret: '#aeafad',
selection: '#264f78',
selectionMatch: '#264f7866',
lineHighlight: '#ffffff0a',
selection: '#3b6ea5',
selectionMatch: '#3b6ea5b3',
lineHighlight: '#ffffff1a',
gutterBackground: '#1e1e1e',
gutterForeground: '#858585',
gutterActiveForeground: '#cccccc',
@@ -226,9 +250,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#ffffff',
foreground: '#333333',
caret: '#000000',
selection: '#add6ff',
selectionMatch: '#add6ff80',
lineHighlight: '#00000008',
selection: '#9ec8f5',
selectionMatch: '#9ec8f5b3',
lineHighlight: '#00000014',
gutterBackground: '#ffffff',
gutterForeground: '#237893',
gutterActiveForeground: '#0b216f',
@@ -239,7 +263,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
},
'one-dark': {
dark: true,
extension: oneDark
// `oneDark` 是现成扩展(不走 createTheme),选中 / 活动行配色是它内置的,
// 因此追加一层覆盖主题把这几处提亮(见 ONE_DARK_HIGHLIGHT)
extension: [oneDark, ONE_DARK_HIGHLIGHT]
},
dracula: {
dark: true,
@@ -249,9 +275,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#282a36',
foreground: '#f8f8f2',
caret: '#f8f8f2',
selection: '#44475a',
selectionMatch: '#44475a80',
lineHighlight: '#ffffff08',
selection: '#5b6079',
selectionMatch: '#5b6079b3',
lineHighlight: '#ffffff1a',
gutterBackground: '#282a36',
gutterForeground: '#6272a4',
gutterActiveForeground: '#f8f8f2',
@@ -268,9 +294,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#002b36',
foreground: '#839496',
caret: '#93a1a1',
selection: '#073642',
selectionMatch: '#07364280',
lineHighlight: '#ffffff08',
selection: '#11505f',
selectionMatch: '#11505fb3',
lineHighlight: '#ffffff1a',
gutterBackground: '#002b36',
gutterForeground: '#586e75',
gutterActiveForeground: '#93a1a1',
@@ -287,9 +313,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#fdf6e3',
foreground: '#657b83',
caret: '#586e75',
selection: '#eee8d5',
selectionMatch: '#eee8d580',
lineHighlight: '#00000008',
selection: '#d9cfae',
selectionMatch: '#d9cfaeb3',
lineHighlight: '#00000014',
gutterBackground: '#fdf6e3',
gutterForeground: '#93a1a1',
gutterActiveForeground: '#586e75',
@@ -306,9 +332,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#2b2b2b',
foreground: '#a9b7c6',
caret: '#bbbbbb',
selection: '#214283',
selectionMatch: '#21428380',
lineHighlight: '#ffffff08',
selection: '#2f5aa8',
selectionMatch: '#2f5aa8b3',
lineHighlight: '#ffffff1a',
gutterBackground: '#313335',
gutterForeground: '#606366',
gutterActiveForeground: '#a1a3a5',
@@ -325,9 +351,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#ffffff',
foreground: '#000000',
caret: '#000000',
selection: '#a6d2ff',
selectionMatch: '#a6d2ff80',
lineHighlight: '#00000008',
selection: '#8dbfef',
selectionMatch: '#8dbfefb3',
lineHighlight: '#00000014',
gutterBackground: '#ffffff',
gutterForeground: '#999999',
gutterActiveForeground: '#666666',
@@ -344,9 +370,9 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
background: '#2d2a2e',
foreground: '#fcfcfa',
caret: '#ffd866',
selection: '#5b595c',
selectionMatch: '#5b595c80',
lineHighlight: '#ffffff08',
selection: '#6f6c74',
selectionMatch: '#6f6c74b3',
lineHighlight: '#ffffff1a',
gutterBackground: '#2d2a2e',
gutterForeground: '#727072',
gutterActiveForeground: '#fcfcfa',
@@ -387,7 +413,7 @@ export function editorBackground(
/** 设置页下拉选项(`system` 置于首位) */
export const EDITOR_THEME_OPTIONS: Array<{ value: string; label: string }> = [
{ value: 'system', label: '跟随应用' },
{ value: 'system', label: '跟随系统' },
{ value: 'vscode-dark', label: 'VS Code 深色' },
{ value: 'vscode-light', label: 'VS Code 浅色' },
{ value: 'one-dark', label: 'One Dark' },
@@ -415,7 +441,14 @@ const THEME_PAIRS: Record<string, { light: string; dark: string }> = {
system: { light: 'vscode-light', dark: 'vscode-dark' }
}
/** 求实际生效的主题名。 */
/**
* 求实际生效的主题名。
*
* 参数 `isDark` 是**编辑器窗口当前的深浅**(见 `EditorWindow.windowIsDark`):
* - `followAppTheme` 开:窗口跟随主应用,`isDark` 即应用的深浅,按配对取对应侧;
* - `followAppTheme` 关:窗口由配色方案决定 —— 具体主题直接用自身,`system`
* (「跟随系统」)则按传给它的深浅取 VS Code 深/浅(此时是应用解析出的系统深浅)。
*/
export function effectiveThemeName(
theme: string,
followAppTheme: boolean,
+26 -1
View File
@@ -155,6 +155,20 @@ export const editorClient = {
// ===== 本地目录(P3-5,操作用户真实文件系统) =====
readDir: (path: string) => invoke<DirListing>('editor_read_dir', { path }),
/**
* 判定一个路径是文件还是文件夹(只探测,不打开)。
*
* 拖放事件只给绝对路径,前端拿不到文件系统元信息,因此复用 `editor_read_dir`
* 探测:能列出即目录(该命令对文件会报错)。探测是只读的,不写盘、不需授权。
*/
pathKind: async (path: string): Promise<'file' | 'folder'> => {
try {
await invoke<DirListing>('editor_read_dir', { path })
return 'folder'
} catch {
return 'file'
}
},
createFile: (dir: string, name: string) => invoke<string>('editor_create_file', { dir, name }),
createDir: (dir: string, name: string) => invoke<string>('editor_create_dir', { dir, name }),
renamePath: (path: string, newName: string) =>
@@ -167,5 +181,16 @@ export const editorClient = {
// ===== 系统集成(P4-4,HKCU 右键菜单) =====
contextMenuStatus: () => invoke<ContextMenuStatus>('editor_context_menu_status'),
registerContextMenu: () => invoke<ContextMenuStatus>('editor_register_context_menu'),
unregisterContextMenu: () => invoke<ContextMenuStatus>('editor_unregister_context_menu')
unregisterContextMenu: () => invoke<ContextMenuStatus>('editor_unregister_context_menu'),
/**
* 给新建的编辑器窗口补注入拖放支持(Windows)。
*
* wry 只在创建 webview 的那一刻扫一次子窗口注入 OLE drop target,而 WebView2 的
* 渲染子窗口是异步创建的 —— 运行期新建的窗口因此拿不到 drop target(拖文件进去
* 是禁止光标)。这里让 Rust 侧在子窗口出现后补注入。非 Windows 是空操作。
*
* 命令是**通用**的(`window_attach_drag_drop`,按传入的 label 生效):对比窗口也用它。
*/
attachDragDrop: (label: string) => invoke<void>('window_attach_drag_drop', { label })
}
+83 -4
View File
@@ -6,6 +6,8 @@
* 直接显示会先闪一下纯白。由 EditorWindow.vue 应用完主题(含窗口效果)再自己 show;
* - **同目标判重聚焦**(规划 §8-Q1 选 (a)):窗口默认多开,但「同一个文件开两个窗口」
* 几乎总是误操作 —— 两个窗口各自自动保存,后写的会覆盖先写的。
* - **已有编辑器窗口时加标签**(复用设置打开时):打开另一个文件 / 目录不再多开窗口,
* 而是 `emitTo` 一个 `editor-open-tab` 给既有窗口,由它加一个标签(见下)。
*
* # label 里为什么是哈希而不是明文路径
*
@@ -16,9 +18,13 @@
* 可以忽略,而代价(不判重)远小于把路径写进 label。
*/
import { WebviewWindow } from '@tauri-apps/api/webviewWindow'
import { emitTo } from '@tauri-apps/api/event'
import { invoke } from '@tauri-apps/api/core'
import { createLogger } from '@/lib/logger'
import { WINDOWS } from '@/lib/constants'
import { EVENTS, WINDOWS } from '@/lib/constants'
import { useEditorStore } from '@/stores/editorStore'
import { editorClient } from './editorClient'
import type { EditorOpenTabPayload } from '@/types/editor'
const logger = createLogger('editor')
@@ -40,19 +46,48 @@ export function labelForTarget(target: string): string {
return `${LABEL_PREFIX}t${hashTarget(target)}`
}
/**
* 显示 + 取消最小化 + 强制置前(按窗口 label)。
*
* 走 Rust 原生 `SetForegroundWindow`(见 `win32_util::force_foreground`)而不是前端
* `show() / unminimize() / setFocus()`:后者受 Windows **前台锁定**限制 —— 快捷键从
* 别的应用触发时「本进程不拥有前台」,`setFocus` 会被系统直接忽略,表现就是
* **窗口明明开着却唤不到前面**(下载窗口 / 快速面板 / 托盘同一处理)。
*/
async function focusWindow(label: string): Promise<void> {
await invoke('window_focus_window', { label })
}
/** 聚焦已经打开该目标的窗口(找到返回 true)。 */
async function focusTarget(target: string): Promise<boolean> {
const existing = await WebviewWindow.getByLabel(labelForTarget(target))
if (!existing) return false
try {
await existing.show()
await existing.setFocus()
await focusWindow(existing.label)
return true
} catch {
return false
}
}
/**
* 找一个**已存在**的编辑器窗口(任意一个),没有则 null。
*
* 与 [`focusTarget`] 的区别:那个要的是「这个目标自己的窗口」,这个要的是「有没有
* 任何一个编辑器窗口可以接收新标签」。两者的判据不同,因此不合并成一个函数。
*/
async function findOpenEditorWindow(): Promise<WebviewWindow | null> {
const windows = await WebviewWindow.getAll()
return windows.find(w => w.label.startsWith(LABEL_PREFIX)) ?? null
}
/** 把打开请求转换成「加标签」负载(三种目标与 `openEditorWindow` 的入参一一对应)。 */
function toTabPayload(options: { relPath?: string; path?: string; folder?: string }): EditorOpenTabPayload {
if (options.relPath) return { relPath: options.relPath }
if (options.folder) return { path: options.folder, folder: true }
return { path: options.path }
}
/**
* 打开一个编辑器窗口。
*
@@ -60,6 +95,9 @@ async function focusTarget(target: string): Promise<boolean> {
* @param options.path 可选:打开时直达的**库外文件**(绝对路径)
* @param options.folder 可选:打开时直达的**本地目录**(绝对路径,目录面板)
* @param options.dedupe 同一目标已开窗口时聚焦它(默认 true)
*
* **无目标**(`Alt+E` / 托盘「打开编辑器」)时:已有编辑器窗口就**唤出它**而不是新开一个
* —— 快捷键的语义是「去编辑」,反复按不该堆出一串空窗口。
*/
export async function openEditorWindow(options?: {
relPath?: string
@@ -76,13 +114,41 @@ export async function openEditorWindow(options?: {
? `?folder=${encodeURIComponent(options.folder)}`
: ''
// 无目标:任何编辑器窗口存在就直接唤出(显示 + 取消最小化 + 强制置前)
if (!target && options?.dedupe !== false) {
const existing = await findOpenEditorWindow()
if (existing) {
try {
await focusWindow(existing.label)
return
} catch (e) {
logger.warn(`唤出既有编辑器窗口失败,改为新建:${String(e)}`)
}
}
}
if (target && options?.dedupe !== false) {
// 「复用文档窗口」是可关闭的设置(默认开)。关掉时每次新建窗口 ——
// 有些用户确实想并排对照同一篇的不同位置。
const reuse = useEditorStore().settings.reuseWindow
if (reuse) {
// ① 这个目标自己已经有窗口:聚焦它(原行为)
const focused = await focusTarget(target)
if (focused) return
// ② 任何编辑器窗口存在:把目标交给它**加标签**,而不是再开一个窗口。
// 「再点一次同一个文件」由 ① 拦住,这里处理的是「打开另一个文件 / 目录」——
// 过去每次都会多出一个窗口,而用户真正想要的是标签栏多一项。
// (编辑器窗口尚未加载完时事件可能落空,属于极窄的竞态:窗口已存在即已在监听。)
const host = await findOpenEditorWindow()
if (host) {
try {
await emitTo(host.label, EVENTS.editorOpenTab, toTabPayload(options ?? {}))
await focusWindow(host.label)
return
} catch (e) {
logger.warn(`向既有编辑器窗口加标签失败,改为新建窗口:${String(e)}`)
}
}
}
}
@@ -106,13 +172,26 @@ export async function openEditorWindow(options?: {
shadow: true,
center: true,
visible: false,
focus: false
focus: false,
// 显式开启 Tauri 原生拖放(拖文件进窗口打开):默认值虽为开,但显式声明可避免
// 依赖「动态创建窗口的默认值」这一隐含前提,且与 capabilities 的意图一致。
dragDropEnabled: true
})
win.once('tauri://error', e => {
logger.error(`打开编辑器窗口失败:${String(e)}`)
})
// 补注入拖放支持:wry 只在创建 webview 那一刻扫一次子窗口,运行期新建的窗口拿不到
// OLE drop target(拖文件进去是禁止光标)。详见 src-tauri/src/editor/drag_drop.rs
//
// 注意**不要**放到下面那个 `await` 之后:`tauri://created` 在窗口创建过快时可能早于
// 监听注册而永远等不到,那个 promise 会一直挂着。Rust 侧会自行重试等待窗口与
// WebView2 子窗口就位,所以这里 fire-and-forget 即可。
void editorClient.attachDragDrop(finalLabel).catch(e => {
logger.warn(`拖放补注入失败:${String(e)}`)
})
await new Promise<void>((resolve, reject) => {
win.once('tauri://created', () => resolve())
win.once('tauri://error', e => reject(new Error(String(e))))
+4 -2
View File
@@ -12,7 +12,8 @@ import {
Languages,
SquareTerminal,
Bot,
FileCode2
FileCode2,
Diff
} from '@lucide/vue'
/**
@@ -35,7 +36,8 @@ export const moduleIconMap: Record<string, Component> = {
translate: Languages,
terminal: SquareTerminal,
dsh: Bot,
editor: FileCode2
editor: FileCode2,
diff: Diff
}
/** 获取模块图标组件,未找到时回退到 Settings 图标 */
+3 -1
View File
@@ -15,6 +15,7 @@ import { moduleConfig as translate } from './translate'
import { moduleConfig as terminal } from './terminal'
import { moduleConfig as dsh } from './dsh'
import { moduleConfig as editor } from './editor'
import { moduleConfig as diff } from './diff'
const allModules: ModuleConfig[] = [
proxy,
@@ -29,7 +30,8 @@ const allModules: ModuleConfig[] = [
translate,
terminal,
dsh,
editor
editor,
diff
]
// 启动时注册所有模块
+27 -45
View File
@@ -2,7 +2,7 @@
import {
Activity, Play, Square, RefreshCw, Loader2, Cpu, MemoryStick,
Gauge, HardDrive, Settings as SettingsIcon, AlertTriangle,
ShieldCheck, ShieldOff, Zap, Thermometer, Clock, ChevronDown,
ShieldCheck, Zap, Thermometer, Clock, ChevronDown,
ArrowDown, ArrowUp, Wifi, FolderOpen, Copy, ListChecks,
Monitor as MonitorIcon, GripVertical, SlidersHorizontal,
Eye, EyeOff, MousePointerClick, Check, PencilLine,
@@ -469,26 +469,15 @@ async function handleRepairPawnio() {
}
}
/** 提权:以管理员权限重启 Thing 自身,并持久化标志使后续启动自动提权。
* Thing 以管理员权限运行时,ThingHK 子进程继承权限,ProcessManager 可直接管控,
* ThingHK 崩溃会自动重启,避免数据停止后 Thing 不感知。
* 非管理员时进程退出;已是管理员时仅设置标志并返回。
*/
async function handleElevateSelf() {
await store.elevateSelf()
// 非管理员时进程已退出,不会走到这里
/** 提权:仅以管理员权限重启 ThingHK 内核(弹 UAC),Thing 自身保持普通权限。
* 提权后可读取完整的 CPU 温度/时钟、存储 SMART、主板/电压等传感器;
* 代价是内核不归 ProcessManager 管(停止走 /shutdown,崩溃不自动重启)。 */
async function handleElevateKernel() {
await store.elevateKernel()
if (store.errorMsg) {
toast.error('提权失败', { description: store.errorMsg })
} else if (store.elevateOnLaunch) {
toast.success('已启用提权', { description: '后续启动将自动以管理员权限运行' })
}
}
/** 取消提权:清除标志,下次启动不再触发 UAC(当前会话权限不变) */
async function handleCancelElevation() {
await store.cancelElevation()
if (!store.errorMsg) {
toast.success('已取消提权', { description: '下次启动将以普通权限运行' })
toast.error('内核提权失败', { description: store.errorMsg })
} else if (store.status?.elevated) {
toast.success('ThingHK 已以管理员权限运行', { description: 'Thing 自身仍为普通权限' })
}
}
@@ -1376,9 +1365,6 @@ watch(() => store.status?.ready, (ready, prev) => {
<Badge :variant="store.snapshot?.isAdmin ? 'default' : 'outline'" :class="store.snapshot?.isAdmin ? 'bg-success hover:bg-success' : ''">
{{ store.snapshot?.isAdmin ? '管理员' : '普通' }}
</Badge>
<Badge v-if="store.status?.thingElevated" variant="outline" class="border-success/50 text-success-text">
<ShieldCheck class="size-2.5 mr-0.5" />提权
</Badge>
</div>
<!-- 指标区:核心属性同样占一个指标位(label 11px 灰 + 数值 18px/600 tabular-nums) -->
<div class="flex flex-wrap items-center gap-6">
@@ -1408,24 +1394,16 @@ watch(() => store.status?.ready, (ready, prev) => {
<Button v-if="store.connState === 'idle' && !store.starting" size="sm" :disabled="store.starting" @click="handleStart">
<Play class="size-3.5" />启动
</Button>
<!-- 提权按钮(标志未启用时显示:设置标志 + 以管理员权限重启 Thing) -->
<Tooltip v-if="!store.elevateOnLaunch">
<!-- 提权按钮:仅以管理员权限重启 ThingHK 内核(Thing 自身保持普通权限)。
提权成功后会记住提权偏好,应用重启后自动以提权方式启动(可在监控设置中关闭)。 -->
<Tooltip v-if="!store.status?.elevated">
<TooltipTrigger as-child>
<Button size="sm" variant="outline" class="gap-1 text-success-text border-success/40 hover:bg-success/10" :disabled="store.starting" @click="handleElevateSelf">
<Button size="sm" variant="outline" class="gap-1 text-success-text border-success/40 hover:bg-success/10" :disabled="store.starting" @click="handleElevateKernel">
<Loader2 v-if="store.starting" class="size-3.5 animate-spin" />
<ShieldCheck v-else class="size-3.5" />提权
<ShieldCheck v-else class="size-3.5" />提权内核
</Button>
</TooltipTrigger>
<TooltipContent class="max-w-[480px] break-words">以管理员权限重启 Thing(弹 UAC,ThingHK 子进程继承权限,后续启动自动提权,崩溃自动重启)</TooltipContent>
</Tooltip>
<!-- 取消提权按钮(标志已启用时显示:清除标志,下次启动不触发 UAC) -->
<Tooltip v-else>
<TooltipTrigger as-child>
<Button size="sm" variant="outline" class="gap-1 text-muted-foreground hover:text-foreground" @click="handleCancelElevation">
<ShieldOff class="size-3.5" />取消提权
</Button>
</TooltipTrigger>
<TooltipContent class="max-w-[480px] break-words">取消提权,下次启动将以普通权限运行(不影响当前会话)</TooltipContent>
<TooltipContent class="max-w-[480px] break-words">仅以管理员权限重启 ThingHK 内核(弹 UAC),Thing 自身保持普通权限。提权后可读取 CPU 温度/时钟、存储 SMART、主板/电压;停止走内核 /shutdown,崩溃不自动重启。成功后记住提权偏好,应用重启后自动沿用(可在监控设置中关闭)</TooltipContent>
</Tooltip>
<!--
刷新:图标按钮(原来是与启动/停止同级的文字按钮,把操作区撑宽
@@ -2330,6 +2308,17 @@ watch(() => store.status?.ready, (ready, prev) => {
@update:model-value="(v: boolean) => store.setAutoStart(v)"
/>
</div>
<!-- 内核启动时提权 toggle:提权偏好持久化,重启应用后自动沿用(弹 UAC) -->
<div class="flex items-center justify-between rounded-md border p-3">
<div>
<p class="text-sm">内核启动时以管理员权限运行</p>
<p class="text-xs text-muted-foreground">启动内核时弹 UAC 提权,Thing 自身保持普通权限;开启后应用重启仍保持提权</p>
</div>
<Switch
:model-value="store.elevateOnStart"
@update:model-value="(v: boolean) => store.setElevateOnStart(v)"
/>
</div>
</CardContent>
</Card>
@@ -2401,9 +2390,6 @@ watch(() => store.status?.ready, (ready, prev) => {
<Badge :variant="store.snapshot?.isAdmin ? 'default' : 'outline'" :class="store.snapshot?.isAdmin ? 'bg-success hover:bg-success' : ''">
{{ store.snapshot?.isAdmin ? '管理员' : '普通' }}
</Badge>
<Badge v-if="store.status?.thingElevated" variant="outline" class="border-success/50 text-success-text">
<ShieldCheck class="size-2.5 mr-0.5" />提权
</Badge>
</div>
</div>
<Separator />
@@ -2416,14 +2402,10 @@ watch(() => store.status?.ready, (ready, prev) => {
<div class="flex items-start gap-2">
<ShieldCheck class="size-3.5 mt-0.5 shrink-0 text-success" />
<div class="text-xs">
<span class="font-medium text-foreground">提权</span>:以管理员权限重启 Thing 自身,ThingHK 子进程继承权限。标志持久化,后续每次启动自动触发 UAC;可在概览页点击"取消提权"关闭。ThingHK 崩溃由 ProcessManager 自动重启,避免数据停止后 Thing 不感知。
<span class="font-medium text-foreground">提权内核</span>:仅以管理员权限重启 ThingHK 内核(弹 UAC),Thing 自身始终以普通权限运行。该状态不持久化,重启内核即回到普通权限。提权内核不归 ProcessManager 管:停止走内核 /shutdown 接口,崩溃不自动重启,需手动重新提权。
</div>
</div>
</div>
<p v-if="store.status?.thingElevated" class="text-xs leading-relaxed text-success-text flex items-start gap-1.5">
<ShieldCheck class="size-3.5 mt-0.5 shrink-0" />
<span>提权模式:Thing 与 ThingHK 均以管理员权限运行,ProcessManager 可直接 kill,崩溃自动重启可用。</span>
</p>
</CardContent>
</Card>
+6
View File
@@ -51,6 +51,12 @@ const searchItems: SearchIndexItem[] = [
keywords: ['自动启动', '开机', '内核', 'autoStart'],
tab: 'settings'
},
{
title: '内核启动时提权',
description: '内核以管理员权限运行,应用重启后保持提权',
keywords: ['提权', '管理员', 'uac', 'elevate', 'admin', '内核'],
tab: 'settings'
},
{
title: '监控项配置',
description: '选择要监控的传感器分组与项目',
+7
View File
@@ -26,6 +26,7 @@
* 因此这里除了切 class 还要设**窗口底色**,否则显示瞬间是白底。
*/
import { onBeforeUnmount, onMounted, ref } from 'vue'
import { invoke } from '@tauri-apps/api/core'
import { getCurrentWindow } from '@tauri-apps/api/window'
import { FolderTree, Loader2, Minus, Square, X } from '@lucide/vue'
import { toast } from 'vue-sonner'
@@ -100,6 +101,12 @@ onMounted(async () => {
// 主题 → 显示:窗口是隐藏创建的,这一步之后用户才第一次看到它
await applyTheme()
// 任务栏身份:窗口级 AUMID(独立任务栏按钮)+ 组合图标;必须在 show() 之前设置
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'files' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try {
await win.show()
await win.setFocus()
+7
View File
@@ -47,6 +47,7 @@
* 语义:主窗口那侧的「已在独立窗口中打开」提示条、标签上的「独立」徽标都以此为准。
*/
import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
import { invoke } from '@tauri-apps/api/core'
import { getCurrentWindow } from '@tauri-apps/api/window'
import {
AlertTriangle,
@@ -192,6 +193,12 @@ async function applyTheme() {
* 放在 `applyTheme` 之后,用户看到的第一帧就是正确配色。
*/
async function revealWindow() {
// 任务栏身份:窗口级 AUMID(独立任务栏按钮)+ 组合图标;必须在 show() 之前设置
try {
await invoke('window_set_taskbar_identity', { label: win.label, kind: 'terminal' })
} catch (e) {
logger.warn(`设置任务栏身份失败:${String(e)}`)
}
try {
await win.show()
await win.setFocus()
+156 -17
View File
@@ -9,6 +9,7 @@ import { Effect, EffectState } from '@tauri-apps/api/window'
import {
Globe, Power, PowerOff, RefreshCw, Check, Monitor, LogOut,
Play, Pause, SkipBack, SkipForward, Music, SquareTerminal, Bot, FileCode2,
Repeat, Repeat1, Shuffle, Volume1, Volume2, VolumeX,
} from '@lucide/vue'
import {
Select, SelectContent, SelectItem, SelectTrigger, SelectValue,
@@ -33,8 +34,15 @@ interface MusicState {
playing: boolean
title: string
artist: string
/** 当前音量(0.0~1.0),来自 Rust 播放引擎 */
volume: number
muted: boolean
}
/** 播放顺序(与 `feiniuStore` 的 `thing.music.playmode` 同一份 localStorage) */
type PlayMode = 'loopAll' | 'loopOne' | 'shuffle'
const PLAY_MODE_KEY = 'thing.music.playmode'
const state = reactive<TrayMenuState>({
proxyRunning: false,
systemProxy: false,
@@ -43,7 +51,11 @@ const state = reactive<TrayMenuState>({
proxyNodes: [],
proxyCurrent: null,
})
const music = reactive<MusicState>({ playing: false, title: '', artist: '' })
const music = reactive<MusicState>({ playing: false, title: '', artist: '', volume: 1, muted: false })
/** 播放顺序:真相在主窗口前端的 feiniuStore(localStorage 同步),托盘只读来显示图标 */
const playMode = ref<PlayMode>('loopAll')
/** 音量面板是否展开(展开时窗口需要长高,见 toggleVolumePanel) */
const volumeOpen = ref(false)
const loadingAction = ref<string | null>(null)
const refreshing = ref(false)
const osdVisible = ref(false)
@@ -53,6 +65,8 @@ const unlistenFns: UnlistenFn[] = []
/** 菜单关闭/失焦前重置状态:关闭节点下拉框并取消所有焦点,避免下次打开时残留 */
function resetMenuState() {
nodeSelectOpen.value = false
// 音量面板随菜单收起一并复位:下次弹出应回到简洁的两行
volumeOpen.value = false
if (document.activeElement instanceof HTMLElement) {
document.activeElement.blur()
}
@@ -314,22 +328,71 @@ function handleSelectNode(name: unknown) {
// 与普通菜单项不同:点音乐按钮**不关闭菜单**(用户常要连点下一首),
// 因此不走 handleAction(它会 hide 菜单 + 取消焦点),而是单独一条路径。
/** 从 localStorage 读播放顺序(主窗口 feiniuStore 写的是同一个键) */
function readPlayMode() {
try {
const v = localStorage.getItem(PLAY_MODE_KEY)
if (v === 'loopAll' || v === 'loopOne' || v === 'shuffle') playMode.value = v
} catch { /* localStorage 不可用时保持默认 */ }
}
/** 拉取一次音乐状态(本地查询,开销极小) */
async function refreshMusic() {
try {
Object.assign(music, await invoke<MusicState>('tray_music_state'))
const s = await invoke<MusicState>('tray_music_state')
// 音量面板展开 / 拖动期间不覆盖本地值:1s 轮询会把用户正在拖的滑块拽回去
if (!volumeOpen.value) Object.assign(music, s)
else music.playing = s.playing
} catch { /* 忽略 */ }
readPlayMode()
}
async function handleMusicControl(action: 'toggle' | 'next' | 'prev') {
type MusicAction = 'toggle' | 'next' | 'prev' | 'toggle-mode' | 'toggle-mute'
async function handleMusicControl(action: MusicAction) {
// 乐观翻转播放态:动作要经主窗口前端执行(异步),先改本地避免按钮有明显延迟;
// 真实值由 1s 轮询纠正
if (action === 'toggle') music.playing = !music.playing
try {
await invoke('tray_music_control', { action })
} catch { /* 忽略 */ }
// 播放顺序 / 静音是本地读的,改完立刻重读一次(不必等下一轮轮询)
if (action === 'toggle-mode' || action === 'toggle-mute') readPlayMode()
}
/** 音量变化(拖动 / 点击轨道):直接改 Rust 引擎,即时出声 */
let volumeSentAt = 0
async function handleVolumeInput(value: number): Promise<void> {
music.volume = value
// 节流:range 的 input 事件很密,50ms 一次足够跟手,避免刷爆 IPC
const now = Date.now()
if (now - volumeSentAt < 50) return
volumeSentAt = now
try {
await invoke('tray_music_control', { action: 'volume', level: value })
} catch { /* 忽略 */ }
}
/** 音量面板开合:面板在正常流里长高/收起,需重新测高让窗口跟着变,否则滑块会被裁掉 */
async function toggleVolumePanel() {
volumeOpen.value = !volumeOpen.value
await nextTick()
await measureAndShow()
}
/** 音量图标:静音 / 低音量 / 正常 */
const volumeIcon = computed(() =>
music.muted || music.volume <= 0 ? VolumeX : music.volume < 0.5 ? Volume1 : Volume2
)
/** 播放顺序图标与说明 */
const modeIcon = computed(() =>
playMode.value === 'loopOne' ? Repeat1 : playMode.value === 'shuffle' ? Shuffle : Repeat
)
const modeTitle = computed(() =>
playMode.value === 'loopAll' ? '列表循环' : playMode.value === 'loopOne' ? '单曲循环' : '随机播放'
)
/** 音乐状态轮询定时器(仅菜单可见时运行) */
let musicTimer: number | null = null
@@ -370,9 +433,10 @@ function onKeydown(e: KeyboardEvent) {
}
const MENU_MIN_HEIGHT = 200
const MENU_MAX_HEIGHT = 520
/** 测量内容高度(逻辑像素) */
/** 测量内容高度(逻辑像素)。
* 不做上限截断:窗口按内容完整撑开,菜单不出现滚动条;
* 仅当内容超出光标上方的屏幕可用空间时,才由 Rust 侧 tray_menu_ready 收窄并退化为滚动。 */
function measureContentHeight(): number {
const root = document.querySelector('.tray-menu-root') as HTMLElement | null
if (!root) return MENU_MIN_HEIGHT
@@ -382,7 +446,7 @@ function measureContentHeight(): number {
if (scroll) scroll.style.maxHeight = 'none'
const height = root.scrollHeight
if (scroll) scroll.style.maxHeight = prevMax
return Math.min(Math.max(height, MENU_MIN_HEIGHT), MENU_MAX_HEIGHT)
return Math.max(height, MENU_MIN_HEIGHT)
}
/** 测量内容高度并通知 Rust 调整窗口大小、定位、显示 */
@@ -539,14 +603,23 @@ onUnmounted(() => {
<template>
<div class="tray-menu-root flex flex-col" @keydown="onKeydown" tabindex="0">
<div class="tray-menu-scroll flex-1 min-h-0 overflow-y-auto">
<!-- 音乐控制条(代理之上):当前曲目 + 上一首/播放暂停/下一首 -->
<!-- 音乐控制条(代理之上):第一行曲目信息,第二行播放控制(一行太挤) -->
<div class="tray-music">
<Music class="size-4 shrink-0 tray-music-icon" />
<div class="tray-music-text">
<span class="tray-music-title">{{ music.title || '未在播放' }}</span>
<span class="tray-music-artist">{{ music.artist || (music.title ? '未知歌手' : '') }}</span>
<div class="tray-music-info">
<Music class="size-4 shrink-0 tray-music-icon" />
<div class="tray-music-text">
<span class="tray-music-title">{{ music.title || '未在播放' }}</span>
<span class="tray-music-artist">{{ music.artist || (music.title ? '未知歌手' : '') }}</span>
</div>
</div>
<div class="tray-music-actions">
<button
class="tray-music-btn"
:title="modeTitle"
@click="handleMusicControl('toggle-mode')"
>
<component :is="modeIcon" class="size-4" />
</button>
<button
class="tray-music-btn"
:disabled="!music.title"
@@ -567,6 +640,37 @@ onUnmounted(() => {
>
<SkipForward class="size-4" />
</button>
<button
class="tray-music-btn"
:class="volumeOpen && 'bg-active'"
:title="music.muted ? '已静音(点击调节音量)' : `音量 ${Math.round(music.volume * 100)}%`"
@click="toggleVolumePanel"
>
<component :is="volumeIcon" class="size-4" />
</button>
</div>
<!-- 音量面板:点音量按钮后展开(窗口是内容自适应高度,浮层会被裁切,故用内联展开) -->
<div v-if="volumeOpen" class="tray-music-volume">
<button
class="tray-music-btn"
:title="music.muted ? '取消静音' : '静音'"
@click="handleMusicControl('toggle-mute')"
>
<VolumeX v-if="music.muted" class="size-4" />
<Volume2 v-else class="size-4" />
</button>
<input
class="tray-volume-slider"
type="range"
min="0"
max="1"
step="0.01"
:value="music.muted ? 0 : music.volume"
title="音量"
@input="handleVolumeInput(Number(($event.target as HTMLInputElement).value))"
/>
<span class="tray-volume-value">{{ Math.round((music.muted ? 0 : music.volume) * 100) }}</span>
</div>
</div>
@@ -699,7 +803,9 @@ onUnmounted(() => {
.tray-menu-scroll {
padding: 6px;
overflow-y: auto;
max-height: 520px;
/* 仅作为兜底:正常情况下窗口高度 = 内容高度(不滚动);
内容超出窗口(屏幕空间不足被 Rust 收窄)时才出现滚动条 */
max-height: 100vh;
}
.tray-menu-scroll::-webkit-scrollbar {
@@ -757,14 +863,23 @@ onUnmounted(() => {
opacity: 0.5;
}
/* ===== 音乐控制条(代理之上) ===== */
/* ===== 音乐控制条(代理之上) =====
两行:上行曲目信息,下行播放控制 —— 一行放「图标 + 曲名 + 歌手 + 三个按钮」太挤,
长曲名只能截到几个字。 */
.tray-music {
display: flex;
flex-direction: column;
gap: 6px;
padding: 8px 10px;
border-radius: 6px;
}
.tray-music-info {
display: flex;
align-items: center;
gap: 8px;
padding: 7px 10px;
border-radius: 6px;
min-width: 0;
}
.tray-music-icon {
@@ -800,8 +915,8 @@ onUnmounted(() => {
.tray-music-actions {
display: flex;
align-items: center;
gap: 2px;
flex-shrink: 0;
justify-content: center;
gap: 8px;
}
.tray-music-btn {
@@ -839,6 +954,30 @@ onUnmounted(() => {
background: color-mix(in oklch, var(--primary) 22%, transparent);
}
/* 音量面板(点音量按钮后展开的第三行) */
.tray-music-volume {
display: flex;
align-items: center;
gap: 6px;
}
.tray-volume-slider {
flex: 1;
min-width: 0;
height: 18px;
cursor: pointer;
/* 用原生 range + accent-color:与主题同色,且天然支持键盘 / 无障碍 */
accent-color: var(--primary);
}
.tray-volume-value {
min-width: 26px;
text-align: right;
font-size: 10.5px;
color: var(--muted-foreground);
font-variant-numeric: tabular-nums;
}
.tray-item {
display: flex;
align-items: center;