This commit is contained in:
zhongluofeng committed 2026-10-10 14:29:48 +08:00
1 parent ad987111a3
commit c9e61f38c5
89 files changed
+11775 -3155

No files matched your search

+212
View File
@@ -0,0 +1,212 @@
<script setup lang="ts">
/**
* dsh「启动进度」独立窗口(`#dsh-window`)。
*
* # 用途
*
* 托盘菜单点「dsh」时,若服务未启动/未就绪,主窗口会先开这个窗口,再同步拉起
* 服务(`dsh_start`)—— 用户立刻能看到进度,而不是干等一个没有任何反馈的托盘点击。
*
* # 职责边界:本窗口只渲染,不编排
*
* 窗口自己轮询 `dsh_env_status`(本地状态查询,轻量)+ `dsh_log_tail` 渲染进度;
* **何时切换到 Web 界面由主窗口负责**(它持有带令牌地址与 `openWebWindow`):
* 就绪后主窗口打开 `dsh-web` 窗口并关闭本窗口。这样远端页面永远不会挂在本窗口
* 的 label 上(本窗口登记了 capability,不能让远端页面拿到 IPC)。
*
* # 隐藏创建
*
* 窗口由前端**隐藏创建**(见 dshStore.openProgressWindow),本组件应用完主题
* (含 `setBackgroundColor`)再 show —— 否则深色模式下会先闪一个纯白窗口。
*/
import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
import { invoke } from '@tauri-apps/api/core'
import { getCurrentWindow } from '@tauri-apps/api/window'
import { AlertCircle, Bot, CheckCircle2, Loader2, Minus, X } from '@lucide/vue'
import { Button } from '@/components/ui/button'
import { createLogger } from '@/lib/logger'
import { applyStoredAccent } from '@/lib/theme'
import { STORAGE_KEYS } from '@/lib/constants'
import type { DshEnvStatus, DshServerStatus } from '@/types/dsh'
const logger = createLogger('dsh')
const win = getCurrentWindow()
/** 与 style.css 的 --background 对齐:浅色 #ffffff / 深色 #16161a */
const WINDOW_BG = { light: '#ffffff', dark: '#16161a' }
function readMainTheme(): string {
try {
const raw = localStorage.getItem(STORAGE_KEYS.appSettings)
if (raw) return (JSON.parse(raw) as { theme?: string }).theme ?? 'system'
} catch {
/* 设置不可读时按跟随系统处理 */
}
return 'system'
}
function resolveIsDark(theme: string): boolean {
if (theme === 'dark') return true
if (theme === 'light') return false
return window.matchMedia('(prefers-color-scheme: dark)').matches
}
async function applyTheme() {
const root = document.documentElement
const theme = readMainTheme()
const isDark = resolveIsDark(theme)
try {
await win.setTheme(theme === 'system' ? null : (theme as 'dark' | 'light'))
} catch {
/* 平台不支持时忽略 */
}
try {
// 底色单独 try:setTheme 失败不该连带跳过底色,否则仍会白底闪一下
await win.setBackgroundColor(isDark ? WINDOW_BG.dark : WINDOW_BG.light)
} catch {
/* 忽略 */
}
root.classList.toggle('dark', isDark)
applyStoredAccent(root, isDark ? 'dark' : 'light', STORAGE_KEYS.appSettings)
}
// ===== 状态 =====
const server = ref<DshServerStatus | null>(null)
const logTail = ref('')
/** 距本次打开已过去的秒数(服务启动通常几秒~几十秒,给个可见的时间参照) */
const elapsed = ref(0)
/** 就绪:已监听 + 已拿到带令牌地址(主窗口据此打开界面) */
const canOpen = computed(() => !!server.value?.ready && !!server.value?.launchUrl)
const failed = computed(() => !!server.value?.error)
/** 阶段文案:按状态逐级推进(就绪由主窗口接手切界面) */
const stageText = computed(() => {
const s = server.value
if (!s) return '读取状态…'
if (s.error) return '启动失败'
if (s.ready && s.launchUrl) return '已就绪,正在打开界面…'
if (s.ready) return '等待访问地址(令牌)…'
if (s.running) return '服务启动中…'
return '准备启动…'
})
const timer = ref<ReturnType<typeof setInterval> | null>(null)
const logTimer = ref<ReturnType<typeof setInterval> | null>(null)
/**
* 状态查询的时间上限(秒)。
*
* 就绪探测最多 60s(Rust `READY_TIMEOUT`),主窗口的等待也以此为准;留点余量后
* 停止查询——否则用户把窗口留在那儿时,会一直以 1Hz 探测 Node 版本。
*/
const MAX_POLL_SECONDS = 75
async function refreshState() {
try {
const env = await invoke<DshEnvStatus>('dsh_env_status')
server.value = env.server
} catch (e) {
logger.error('读取 dsh 状态失败: ' + e)
}
}
async function refreshLog() {
try {
logTail.value = await invoke<string>('dsh_log_tail', { lines: 6 })
} catch {
/* 日志读取失败不影响进度显示 */
}
}
function minimize() {
void win.minimize()
}
function closeWindow() {
void win.close()
}
onMounted(async () => {
await applyTheme()
try {
await win.show()
await win.setFocus()
} catch (e) {
logger.warn(`显示 dsh 启动窗口失败:${String(e)}`)
}
await refreshState()
await refreshLog()
timer.value = setInterval(() => {
elapsed.value += 1
// 到达终态(就绪 / 失败)后停止状态查询:`dsh_env_status` 会探测 Node 版本
// (跑一次 `node --version` 子进程),没必要在窗口留守期间持续消耗。
// 就绪后主窗口会立刻关掉本窗口;失败时停在错误上即可。
if (!canOpen.value && !failed.value && elapsed.value <= MAX_POLL_SECONDS) void refreshState()
}, 1000)
logTimer.value = setInterval(() => {
if (!failed.value) void refreshLog()
}, 1500)
})
onBeforeUnmount(() => {
if (timer.value) clearInterval(timer.value)
if (logTimer.value) clearInterval(logTimer.value)
})
</script>
<template>
<div class="flex h-screen w-screen flex-col overflow-hidden bg-background text-foreground">
<!-- 控制栏:标题(兼拖拽区)+ 关闭 -->
<div class="flex h-9 shrink-0 items-center gap-1 border-b border-border px-1.5">
<div class="flex h-full min-w-0 flex-1 items-center gap-1.5 px-2" data-tauri-drag-region>
<Bot class="pointer-events-none size-3.5 shrink-0 text-muted-foreground" />
<span class="pointer-events-none truncate text-xs font-medium">DeepSeek Harness</span>
</div>
<Button variant="ghost" size="icon-sm" @click="minimize">
<Minus class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
class="hover:!bg-destructive hover:!text-destructive-foreground"
@click="closeWindow"
>
<X class="size-3.5" />
</Button>
</div>
<div class="flex min-h-0 flex-1 flex-col gap-3 px-4 py-4">
<!-- 阶段:图标 + 文案 + 计时 -->
<div class="flex items-center gap-2.5">
<CheckCircle2 v-if="canOpen" class="size-4 shrink-0 text-success" />
<AlertCircle v-else-if="failed" class="size-4 shrink-0 text-danger" />
<Loader2 v-else class="size-4 shrink-0 animate-spin text-primary" />
<span class="text-[13px] font-medium" :class="{ 'text-danger': failed }">{{ stageText }}</span>
<span class="ml-auto text-[11px] tabular-nums text-muted-foreground">{{ elapsed }}s</span>
</div>
<!-- 失败原因:留在眼前,避免用户只看到托盘「没反应」 -->
<div
v-if="server?.error"
class="rounded-md border border-border bg-danger-soft px-3 py-2 text-[12px] text-danger-text"
>
{{ server.error }}
</div>
<!-- 启动输出尾部:给「进度」一个可读的落点 -->
<div class="flex min-h-0 flex-1 flex-col gap-1.5">
<span class="text-[11px] text-muted-foreground">启动输出</span>
<pre
class="min-h-0 flex-1 overflow-auto whitespace-pre-wrap break-all rounded-md border border-border bg-secondary/40 px-2.5 py-2 font-mono text-[11px] leading-relaxed text-fg-secondary"
>{{ logTail || '(暂无输出)' }}</pre>
</div>
<p v-if="canOpen" class="text-[11px] text-muted-foreground">
界面即将在独立窗口中打开,本窗口会自动关闭。
</p>
</div>
</div>
</template>
@@ -2,7 +2,7 @@
/**
* 笔记模块主页面 —— **只做设置与管理,不做编辑**。
*
* 编辑发生在独立窗口(`openNotesWindow()`),本页负责:库状态与入口、库根管理、
* 编辑发生在独立窗口(`openEditorWindow()`),本页负责:库状态与入口、库根管理、
* 编辑器偏好。所有设置**即时生效、无保存按钮**。
*
* 版式遵循 `UI_DESIGN_SYSTEM.md`:
@@ -23,12 +23,14 @@ import {
ExternalLink,
Eye,
FolderOpen,
FolderPlus,
Keyboard,
Library,
NotebookPen,
Palette,
RefreshCw,
Tags
Tags,
Wrench
} from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Tabs, TabsContent } from '@/components/ui/tabs'
@@ -46,34 +48,35 @@ import {
import { ConfirmDialog, SettingRow, StateBlock } from '@/components/common'
import { useModuleTabs } from '@/lib/use-module-tabs'
import { WINDOWS } from '@/lib/constants'
import { useNotesStore } from '@/stores/notesStore'
import { openNotesWindow } from './openWindow'
import { notesClient } from './notesClient'
import { useEditorStore } from '@/stores/editorStore'
import { openEditorWindow } from './openWindow'
import { editorClient } from './editorClient'
import { EDITOR_THEME_OPTIONS } from './editor/themes'
import WebdavPanel from './components/WebdavPanel.vue'
import ImportExportPanel from './components/ImportExportPanel.vue'
import NewNoteDialog from './components/NewNoteDialog.vue'
import type { NoteSettings } from '@/types/notes'
import type { ContextMenuStatus, EditorSettings } from '@/types/editor'
const store = useNotesStore()
const store = useEditorStore()
const activeTab = ref('overview')
// Tab 结构(规划 §8-Q5):概览 / 库 / 编辑器 / 同步。
// 「关于」并入概览(模块信息量不足以独占一页),设置项按主题归入对应页。
// Tab 结构(规划 §6.1):概览 / 库 / 编辑器 / 集成。
// 「同步」并入「库」(同步是库的属性);「集成」放文件关联 / 右键菜单 / 单实例。
useModuleTabs(
'notes',
'editor',
activeTab,
[
{ value: 'overview', label: '概览' },
{ value: 'library', label: '库' },
{ value: 'editor', label: '编辑器' },
{ value: 'sync', label: '同步' }
{ value: 'integration', label: '集成' }
],
{ alwaysVisible: true }
)
onMounted(() => {
void store.init()
void loadContextMenu()
})
onBeforeUnmount(() => {
store.disposeListeners()
@@ -98,25 +101,26 @@ watch(
/**
* 冷启动的「用 Thing 打开」:命令行留下的文件路径取到后,直接开一个笔记窗口。
*
* **只在主窗口做**:笔记窗口内部也会渲染本模块(`#notes-window` 是独立入口,
* 不走这里),但它的 hash 里已经带了 `?path=`,由 `NotesWindow` 自己打开 ——
* **只在主窗口做**:笔记窗口内部也会渲染本模块(`#editor-window` 是独立入口,
* 不走这里),但它的 hash 里已经带了 `?path=`,由 `EditorWindow` 自己打开 ——
* 这里再响应一次就会开第二个窗口。
*/
watch(
() => store.pendingOpenPath,
path => {
if (!path || isNotesWindow()) return
void openNotesWindow({ path }).catch(e => toast.error(`打开文件失败:${String(e)}`))
() => store.pendingOpenTarget,
target => {
if (!target || isEditorWindow()) return
const options = target.kind === 'folder' ? { folder: target.path } : { path: target.path }
void openEditorWindow(options).catch(e => toast.error(`打开失败:${String(e)}`))
}
)
/** 当前是否运行在笔记独立窗口里(hash 形如 `#notes-window?...`)。 */
function isNotesWindow(): boolean {
return window.location.hash.startsWith(`#${WINDOWS.notesWindow}`)
/** 当前是否运行在编辑器独立窗口里(hash 形如 `#editor-window?...`)。 */
function isEditorWindow(): boolean {
return window.location.hash.startsWith(`#${WINDOWS.editorWindow}`)
}
// ===== 设置写入(即时生效) =====
function commit(patch: Partial<NoteSettings>): void {
function commit(patch: Partial<EditorSettings>): void {
void store.patchSettings(patch)
}
@@ -126,7 +130,7 @@ function onNumber(
) {
const value = Number((event.target as HTMLInputElement).value)
if (!Number.isFinite(value)) return
commit({ [patchKey]: value } as Partial<NoteSettings>)
commit({ [patchKey]: value } as Partial<EditorSettings>)
}
// ===== 库根 =====
@@ -175,7 +179,7 @@ async function copyRoot(): Promise<void> {
async function openEditor(): Promise<void> {
try {
await openNotesWindow()
await openEditorWindow()
} catch (e) {
toast.error(`打开编辑器失败:${String(e)}`)
}
@@ -190,13 +194,80 @@ async function openExternalFile(): Promise<void> {
title: '打开文件'
})
if (typeof selected !== 'string') return
await notesClient.authorizeFile(selected)
await openNotesWindow({ path: selected })
await editorClient.authorizeFile(selected)
await openEditorWindow({ path: selected })
} catch (e) {
toast.error(`打开文件失败:${String(e)}`)
}
}
/** 在编辑器窗口里打开一个本地文件夹(目录面板)。 */
async function openFolder(): Promise<void> {
try {
const selected = await open({ directory: true, multiple: false, title: '打开文件夹' })
if (typeof selected !== 'string') return
await openEditorWindow({ folder: selected })
} catch (e) {
toast.error(`打开文件夹失败:${String(e)}`)
}
}
/** 打开一个「最近文件」:库内 `.md` 走笔记语义,其余走库外文件语义。 */
async function openRecentFile(entry: { path: string }): Promise<void> {
const root = (store.libraryRoot || '').replace(/[\\/]+$/, '')
const norm = entry.path.replace(/\//g, '\\').toLowerCase()
if (root && norm.startsWith(root.replace(/\//g, '\\').toLowerCase()) && /\.(md|markdown|mdx)$/i.test(entry.path)) {
const rel = entry.path.slice(root.length).replace(/^[\\/]+/, '').replace(/\\/g, '/')
await openEditorWindow({ relPath: rel })
return
}
await openEditorWindow({ path: entry.path })
}
async function openRecentFolder(entry: { path: string }): Promise<void> {
await openEditorWindow({ folder: entry.path })
}
// ===== 系统集成(P4-4) =====
const contextMenu = ref<ContextMenuStatus | null>(null)
const contextBusy = ref(false)
async function loadContextMenu(): Promise<void> {
try {
contextMenu.value = await editorClient.contextMenuStatus()
} catch (e) {
toast.error(`读取集成状态失败:${String(e)}`)
}
}
async function registerContextMenu(): Promise<void> {
contextBusy.value = true
try {
contextMenu.value = await editorClient.registerContextMenu()
toast.success('已注册右键菜单')
} catch (e) {
toast.error(`注册失败:${String(e)}`)
} finally {
contextBusy.value = false
}
}
async function unregisterContextMenu(): Promise<void> {
contextBusy.value = true
try {
contextMenu.value = await editorClient.unregisterContextMenu()
toast.success('已卸载右键菜单')
} catch (e) {
toast.error(`卸载失败:${String(e)}`)
} finally {
contextBusy.value = false
}
}
watch(activeTab, tab => {
if (tab === 'integration') void loadContextMenu()
})
const rebuilding = ref(false)
async function rebuildIndex(): Promise<void> {
@@ -216,7 +287,7 @@ async function rebuildIndex(): Promise<void> {
async function openDailyNote(): Promise<void> {
try {
await store.openDailyNote()
await openNotesWindow({ relPath: store.currentRelPath })
await openEditorWindow({ relPath: store.currentRelPath })
} catch (e) {
toast.error(`打开日记失败:${String(e)}`)
}
@@ -290,6 +361,9 @@ const indexSummary = computed(() => {
<Button size="sm" variant="outline" @click="openExternalFile">
<FolderOpen class="size-3.5" />打开文件
</Button>
<Button size="sm" variant="outline" @click="openFolder">
<FolderPlus class="size-3.5" />打开文件夹
</Button>
<Button size="sm" @click="openEditor">
<NotebookPen class="size-3.5" />打开编辑器
</Button>
@@ -297,7 +371,7 @@ const indexSummary = computed(() => {
</CardContent>
</Card>
<!-- 最近打开 -->
<!-- 最近打开:文件与文件夹两份列表(与笔记库解耦) -->
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
@@ -307,28 +381,58 @@ const indexSummary = computed(() => {
</CardHeader>
<CardContent class="!px-4">
<StateBlock
v-if="!store.recent.length"
v-if="!store.recentFiles.length && !store.recentFolders.length"
variant="empty"
title="还没有打开过笔记"
description="点上方「打开编辑器」新建或打开一篇笔记"
title="还没有打开过文件"
description="点上方「打开编辑器 / 打开文件 / 打开文件夹」开始"
:min-height="140"
/>
<div v-else class="flex flex-col divide-y divide-divider">
<button
v-for="item in store.recent"
:key="item.relPath"
type="button"
class="flex min-h-13 items-center gap-4 py-2 text-left transition-colors duration-150 outline-none hover:text-primary focus-visible:ring-2 focus-visible:ring-ring/40"
@click="openNotesWindow({ relPath: item.relPath })"
>
<span class="flex min-w-0 flex-1 flex-col gap-0.5">
<span class="truncate text-[13px] text-foreground">
{{ item.name.replace(/\.md$/i, '') }}
</span>
<span class="truncate text-xs text-muted-foreground">{{ item.relPath }}</span>
</span>
<ExternalLink class="size-3.5 shrink-0 text-muted-foreground" />
</button>
<div v-else class="flex flex-col gap-4">
<div v-if="store.recentFiles.length" class="flex flex-col">
<p class="pb-1 text-[11px] font-medium text-muted-foreground">最近文件</p>
<div class="flex flex-col divide-y divide-divider">
<button
v-for="item in store.recentFiles"
:key="item.path"
type="button"
class="flex min-h-13 items-center gap-4 py-2 text-left transition-colors duration-150 outline-none hover:text-primary focus-visible:ring-2 focus-visible:ring-ring/40"
:class="item.exists ? '' : 'opacity-50'"
@click="openRecentFile(item)"
>
<span class="flex min-w-0 flex-1 flex-col gap-0.5">
<span class="truncate text-[13px] text-foreground">
{{ item.name }}
<span v-if="!item.exists" class="text-[11px] text-muted-foreground">(已失效)</span>
</span>
<span class="truncate text-xs text-muted-foreground">{{ item.path }}</span>
</span>
<ExternalLink class="size-3.5 shrink-0 text-muted-foreground" />
</button>
</div>
</div>
<div v-if="store.recentFolders.length" class="flex flex-col">
<p class="pb-1 text-[11px] font-medium text-muted-foreground">最近文件夹</p>
<div class="flex flex-col divide-y divide-divider">
<button
v-for="item in store.recentFolders"
:key="item.path"
type="button"
class="flex min-h-13 items-center gap-4 py-2 text-left transition-colors duration-150 outline-none hover:text-primary focus-visible:ring-2 focus-visible:ring-ring/40"
:class="item.exists ? '' : 'opacity-50'"
@click="openRecentFolder(item)"
>
<span class="flex min-w-0 flex-1 flex-col gap-0.5">
<span class="truncate text-[13px] text-foreground">
{{ item.name }}
<span v-if="!item.exists" class="text-[11px] text-muted-foreground">(已失效)</span>
</span>
<span class="truncate text-xs text-muted-foreground">{{ item.path }}</span>
</span>
<ExternalLink class="size-3.5 shrink-0 text-muted-foreground" />
</button>
</div>
</div>
</div>
</CardContent>
</Card>
@@ -393,7 +497,7 @@ const indexSummary = computed(() => {
</CardHeader>
<CardContent class="!px-4">
<p class="pb-2 text-xs text-muted-foreground">
全文检索与标签依赖一份 SQLite 索引(存放在库内 <code class="font-mono">.notes/</code>)。
全文检索与标签依赖一份 SQLite 索引(存放在库内 <code class="font-mono">.editor/</code>)。
它只是加速层:删掉也能从 Markdown 文件完整重建,不影响笔记本身。
</p>
<div class="flex flex-col divide-y divide-divider">
@@ -441,6 +545,9 @@ const indexSummary = computed(() => {
<!-- 导入 / 导出(P2) -->
<ImportExportPanel />
<!-- WebDAV 备份 / 同步(原「同步」页,并入库页) -->
<WebdavPanel />
</div>
</TabsContent>
@@ -523,7 +630,7 @@ const indexSummary = computed(() => {
<SettingRow
label="显示大纲"
description="在编辑器侧栏显示标题树(Ctrl+Shift+L 可临时切换)"
description="在编辑区右侧抽屉显示标题树(Ctrl+Shift+O 可临时切换)"
>
<Switch
:model-value="store.settings.showOutline"
@@ -675,10 +782,98 @@ const indexSummary = computed(() => {
</div>
</TabsContent>
<!-- ===== 同步(WebDAV) ===== -->
<TabsContent value="sync" class="tab-animate">
<!-- ===== 集成(系统集成) ===== -->
<TabsContent value="integration" class="tab-animate">
<div class="flex flex-col gap-4 pb-4">
<WebdavPanel />
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
<Wrench class="size-4 text-primary" />
系统集成
</CardTitle>
</CardHeader>
<CardContent class="!px-4">
<p class="pb-2 text-xs text-muted-foreground">
让编辑器融入系统:双击文档打开、资源管理器右键、全局快捷键。所有注册都走用户级
(免管理员);开发模式下 exe 路径不稳定,因此<b>右键菜单默认不自动注册</b>。
</p>
<div class="flex flex-col divide-y divide-divider">
<SettingRow
label="文件关联"
description="双击 .md / .markdown / .mdx 用本应用打开(由安装器写入)"
>
<span class="flex items-center gap-1.5 text-xs text-success">
<span class="size-2 rounded-full bg-success" />已启用
</span>
</SettingRow>
<SettingRow
label="单实例"
description="应用已运行时再次打开文件会转交给既有实例,不新起进程"
>
<span class="flex items-center gap-1.5 text-xs text-success">
<span class="size-2 rounded-full bg-success" />已启用
</span>
</SettingRow>
<SettingRow
label="资源管理器右键菜单"
:description="
contextMenu?.registered
? '已注册「用 Thing 编辑器打开」(文件 / 文件夹 / 目录背景)'
: '未注册;注册后可在资源管理器右键直接打开'
"
>
<div class="flex items-center gap-2">
<span
v-if="contextMenu?.registered"
class="flex items-center gap-1.5 text-xs text-success"
>
<span class="size-2 rounded-full bg-success" />已注册
</span>
<Button
v-if="!contextMenu?.registered"
size="sm"
variant="outline"
:disabled="contextBusy"
@click="registerContextMenu"
>
注册
</Button>
<Button
v-else
size="sm"
variant="outline"
:disabled="contextBusy"
@click="unregisterContextMenu"
>
卸载
</Button>
</div>
</SettingRow>
<SettingRow
label="可执行文件路径"
:description="contextMenu?.exePath || '—'"
>
<span
v-if="contextMenu?.isDev"
class="rounded-sm bg-warning-soft px-1.5 py-0.5 text-[10px] text-warning"
>
开发模式
</span>
<span v-else class="text-xs text-muted-foreground">安装目录</span>
</SettingRow>
<SettingRow
label="全局快捷键"
description="打开编辑器 / 新建笔记的键位在「编辑器」页配置"
>
<span class="text-xs text-muted-foreground">见「编辑器」页</span>
</SettingRow>
</div>
</CardContent>
</Card>
</div>
</TabsContent>
</Tabs>
+1000
View File
@@ -0,0 +1,1000 @@
<script setup lang="ts">
/**
* 编辑器独立窗口根组件(`#editor-window`)。
*
* # 为什么是独立窗口
*
* 主模块页只做设置与管理;真正的编辑发生在这里 —— 可多开、可拖到副屏,
* 编辑体验接近一个独立应用(与终端 / 下载 / 翻译窗口同一范式)。
*
* # 生命周期要点
*
* - 窗口由 `openWindow.ts` **隐藏创建**,本组件 `applyTheme` 之后才 `show`
* (否则深色模式下会先闪一下纯白窗口);
* - 自带一份 Pinia(`main.ts` 里为独立窗口注入),store 通过 IPC 与 Rust 对齐;
* - 监听 `editor-settings` / `editor-library-changed` / `editor-file-changed`
* 实现与主窗口及外部编辑器的实时同步。
*
* # P1 新增的三种「异步危险」
*
* 1. **外部改动**:库文件在别的编辑器里被改了,而我们这边有未保存内容 —— 不能
* 静默重载(会丢掉用户刚敲的字),弹出横幅让用户选;
* 2. **打开库外文件**:路径来自系统对话框,必须先 `authorize` 才能写回;
* 3. **大文件**:超过阈值时关掉 Live Preview / 折叠 / 补全(降级在 `core.ts`,
* 这里只负责把 `large` 标记和提示露出来)。
*/
import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { Effect, EffectState, getCurrentWindow } from '@tauri-apps/api/window'
import { open, save } from '@tauri-apps/plugin-dialog'
import { AlertTriangle, History, Minus, NotebookPen, PanelLeft, Square, X } from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Toaster } from '@/components/ui/sonner'
import { Button } from '@/components/ui/button'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
import {
Dialog,
DialogContent,
DialogDescription,
DialogFooter,
DialogHeader,
DialogTitle
} from '@/components/ui/dialog'
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuLabel,
DropdownMenuTrigger
} from '@/components/ui/dropdown-menu'
import { ConfirmDialog, StateBlock } from '@/components/common'
import { 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 LibrarySidebar from './components/LibrarySidebar.vue'
import EditorHost from './components/EditorHost.vue'
import EditorToolbar from './components/EditorToolbar.vue'
import QuickOpen from './components/QuickOpen.vue'
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 { useEditorSearchStore } from '@/stores/editorSearchStore'
import type { Command, EditorView } from '@codemirror/view'
const logger = createLogger('editor')
const win = getCurrentWindow()
const store = useEditorStore()
const searchStore = useEditorSearchStore()
const isDark = ref(false)
const sidebarVisible = ref(true)
const hostRef = ref<InstanceType<typeof EditorHost> | null>(null)
const sidebarRef = ref<InstanceType<typeof LibrarySidebar> | null>(null)
const quickOpen = ref(false)
const cursorColumn = ref(1)
// ===== 统一搜索器(P4-6):一个输入区覆盖「当前文件 / 当前目录 / 笔记库」 =====
const searchOpen = ref(false)
const searchScope = ref<SearchScope>('file')
/** 右侧抽屉模式(`null` = 关闭):大纲 / 双链 / 图谱 */
const drawerMode = ref<'outline' | 'links' | 'graph' | null>(null)
// ===== 主题与窗口效果(与主应用同步) =====
function readMainTheme(): { theme: string; effect: string } {
try {
const raw = localStorage.getItem(STORAGE_KEYS.appSettings)
if (raw) {
const s = JSON.parse(raw) as { theme?: string; effect?: string }
return { theme: s.theme ?? 'system', effect: s.effect ?? 'mica' }
}
} catch {
/* 设置不可读时按默认处理 */
}
return { theme: 'system', effect: 'mica' }
}
function resolveIsDark(theme: string): boolean {
if (theme === 'dark') return true
if (theme === 'light') return false
return window.matchMedia('(prefers-color-scheme: dark)').matches
}
async function applyTheme(): Promise<void> {
const root = document.documentElement
const { theme, effect } = readMainTheme()
try {
await win.setTheme(theme === 'system' ? null : (theme 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}`)
if (dark) root.classList.add('dark')
applyStoredAccent(root, dark ? 'dark' : 'light', STORAGE_KEYS.appSettings)
try {
// setEffects 会直接覆盖当前效果,无需 clearEffects(那个命令未在 capability 中授权)
if (effect === 'mica') {
await win.setEffects({
effects: [Effect.Mica],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
await win.setBackgroundColor('#00000000')
root.style.setProperty('--popup-bg', 'transparent')
} else if (effect === 'acrylic') {
await win.setEffects({
effects: [Effect.Acrylic],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
await win.setBackgroundColor('#00000000')
root.style.setProperty('--popup-bg', 'transparent')
} else {
const bg = dark ? '#16161a' : '#ffffff'
await win.setBackgroundColor(bg)
root.style.setProperty('--popup-bg', bg)
}
} catch {
/* 忽略效果设置失败 */
}
}
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
const onThemeChange = () => void applyTheme()
const onStorageChange = (e: StorageEvent) => {
if (e.key === STORAGE_KEYS.appSettings) void applyTheme()
}
// ===== 窗口控制 =====
const doMinimize = () => win.minimize().catch(() => undefined)
const doToggleMaximize = () => win.toggleMaximize().catch(() => undefined)
/** 关闭窗口确认(任一标签有未保存改动时) */
const closeConfirmOpen = ref(false)
/** 关闭标签确认 */
const tabCloseConfirmOpen = ref(false)
const pendingCloseTabId = ref('')
/** 关闭临时草稿的三选一(保存到别处 / 删除 / 取消) */
const scratchCloseOpen = ref(false)
/** 请求关闭某个标签(脏数据时弹确认;临时草稿则问「保存到别处 / 删除」)。 */
function requestCloseTab(id: string): void {
const tab = store.tabs.find(t => t.id === id)
if (!tab) return
// 草稿优先:它的收尾是「存到别处 or 删掉」,与普通的「未保存改动」不是一回事
if (store.isScratchTab(id)) {
pendingCloseTabId.value = id
scratchCloseOpen.value = true
return
}
const dirty = id === store.activeTabId ? store.dirty : tab.dirty
if (dirty) {
pendingCloseTabId.value = id
tabCloseConfirmOpen.value = true
return
}
store.closeTab(id)
}
/**
* 草稿关闭三选一:保存到别处 / 删除 / 取消。
*
* 「保存」走系统「另存为」对话框(`save()`),落盘后原草稿一并删除 —— 内容已经在新
* 位置了;因为是**复制到用户指定路径**,这也顺带给了草稿一个「正经身份」,此后它不再
* 被认作草稿(判据是路径)。
*/
async function saveScratchAndClose(): Promise<void> {
const id = pendingCloseTabId.value
const tab = store.tabs.find(t => t.id === id)
scratchCloseOpen.value = false
if (!tab) return
store.activateTab(id)
const suggested = store.fileDoc?.name ?? '草稿.txt'
try {
const target = await save({
title: '保存草稿到…',
defaultPath: suggested,
filters: [
{ name: '文本文件', extensions: ['txt'] },
{ name: '所有文件', extensions: ['*'] }
]
})
if (typeof target !== 'string') {
// 用户在系统对话框里取消了:当作没点过,草稿与标签都留着
return
}
await store.saveScratchAs(target)
store.closeTab(id)
toast.success('草稿已保存')
} catch (e) {
toast.error(`保存失败:${String(e)}`)
}
}
/** 草稿关闭:删除临时文件并关掉标签。 */
async function discardScratchAndClose(): Promise<void> {
const id = pendingCloseTabId.value
scratchCloseOpen.value = false
if (!id) return
store.activateTab(id)
try {
await store.discardScratch()
} finally {
store.closeTab(id)
}
}
/** 确认关闭脏标签:先切过去保存,再关闭。 */
async function confirmCloseTab(): Promise<void> {
const id = pendingCloseTabId.value
tabCloseConfirmOpen.value = false
store.activateTab(id)
try {
await store.saveCurrent()
} catch {
/* 保存失败仍关闭(用户已确认) */
}
store.closeTab(id)
}
async function doClose(): Promise<void> {
if (store.anyDirty) {
closeConfirmOpen.value = true
return
}
await forceClose()
}
async function forceClose(): Promise<void> {
const original = store.activeTabId
// 逐个标签切换并保存(保存只作用于活动文档)
for (const tab of [...store.tabs]) {
store.activateTab(tab.id)
try {
await store.saveCurrent()
} catch {
/* 保存失败不阻塞关闭;脏数据仍在编辑器里 */
}
}
// 上面的循环把活动标签挪到了最后一个 —— 复原成用户关闭时正在看的那一篇,
// 会话里的「活动项」才与用户所见一致
if (original) store.activateTab(original)
// 关窗前记录会话(下次无目标打开时恢复)
store.saveSession()
win.close().catch(() => undefined)
}
/**
* 标签集合一变就落一次会话(防抖 300ms)。
*
* 只在关窗时写是不够的:标题栏的关闭按钮走 `forceClose` 会写,但 Alt+F4 / 任务栏
* 关闭不走前端流程,`onBeforeUnmount` 在 WebView 被销毁时也不保证执行 —— 会话就是这么
* 丢的。持续写把这个缺口堵上。
*
* 依赖的是「标签形态」而不是整个 store:光标移动不会触发写盘,光标行只在写入的那一刻
* 取当前值(恢复时是最佳努力,不追求逐次精确)。
*/
const sessionShape = computed(() =>
[store.activeTabId, ...store.tabs.map(t => `${t.kind}|${t.relPath}|${t.path}`)].join('\u0000')
)
let sessionTimer: ReturnType<typeof setTimeout> | null = null
watch(sessionShape, () => {
if (sessionTimer) clearTimeout(sessionTimer)
sessionTimer = setTimeout(() => {
sessionTimer = null
store.saveSession()
}, 300)
})
// ===== 编辑器命令转发 =====
function applyCommand(command: Command): void {
const view = hostRef.value?.getView() as EditorView | null | undefined
if (view) command(view)
}
async function doSave(): Promise<void> {
try {
await store.saveCurrent()
// 成功不弹提示(项目约定:无错误即无声)—— Ctrl+S 是高频动作,toast 反而打扰
} catch (e) {
toast.error(`保存失败:${String(e)}`)
}
}
function onCursorMoved(line: number, column: number): void {
store.setCursorLine(line)
cursorColumn.value = column
}
/** 顶部导航:切侧栏视图(并确保侧栏可见)。 */
function onNav(view: 'library' | 'directory' | 'recent'): void {
sidebarVisible.value = true
store.setSideView(view)
}
// ===== 统一搜索器 =====
/** 取当前 CM6 视图(未打开文档时为 null)。 */
function getEditorView(): EditorView | null {
return hostRef.value?.getView() ?? null
}
/** 从路径取所在目录(同时兼容 `\` 与 `/`)。 */
function dirNameOf(path: string): string {
const index = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'))
return index > 0 ? path.slice(0, index) : ''
}
/**
* 「当前目录」的检索根。
*
* 优先用侧栏已打开的目录;没有就用**当前文件所在目录** —— 用户在编辑某个文件时
* 想「在这个文件附近找一下」,这是最符合直觉的默认。
*/
const searchDir = computed(() => {
if (store.dirListing?.cwd) return store.dirListing.cwd
if (store.kind === 'file' && store.fileDoc?.path) return dirNameOf(store.fileDoc.path)
if (store.kind === 'note' && store.currentRelPath) {
return dirNameOf(store.noteAbsPath(store.currentRelPath))
}
return ''
})
const libraryPath = computed(() => store.info?.root ?? '')
function openSearch(scope: SearchScope = 'file'): void {
searchScope.value = scope
searchOpen.value = true
}
/** 结果点击:打开文件并跳到那一行(检索期间文件可能已被改动,由 jumpToLine 夹取)。 */
async function onSearchOpenFile(payload: {
path: string
line: number
column: number
}): Promise<void> {
try {
await store.openDoc(payload.path)
} catch (e) {
toast.error(`打开失败:${String(e)}`)
return
}
await nextTick()
hostRef.value?.jumpToLine(payload.line, payload.column)
}
/**
* 新建临时草稿文件(工具条的「新建临时文件」)。
*
* 文件落在 `{app_data_dir}/editor/scratch/`,**不随应用退出删除** —— 只有用户关闭这个
* 文件时才会被问「保存到别处 / 删除」(见 `requestCloseTab`)。
*/
async function doNewScratch(): Promise<void> {
try {
await store.newScratchFile()
} catch (e) {
toast.error(`新建临时文件失败:${String(e)}`)
}
}
/**
* 目录 / 库的批量替换完成:磁盘上一批文件已被改写,当前文档可能就是其中之一。
*
* 走 `reloadAfterExternal`:没有未保存改动就直接重载;有改动只挂 `externalChange`
* 提示,绝不静默丢掉用户正在写的内容(取舍见 store 里的注释)。库内文件另外还有
* 文件监听事件负责刷新侧栏,这里只管当前文档。
*/
async function onPathReplaced(result: PathReplaceResult): Promise<void> {
await store.reloadAfterExternal()
const scope = `${result.replacements} 处 / ${result.filesChanged} 个文件`
if (result.skipped.length) {
// 跳过的原因(编码装不下替换内容 / 写入失败 / 编码无法字节级还原)逐个记日志:
// toast 只报数量,具体到哪个文件为什么跳过看日志更合适
logger.warn(
`目录替换跳过 ${result.skipped.length} 个文件:` +
result.skipped.map(s => `${s.path}(${s.reason})`).join(';')
)
toast.warning(`已替换 ${scope},${result.skipped.length} 个文件被跳过(原因见日志)`)
} else if (result.truncated) {
toast.warning(`已替换 ${scope}(达到上限,未处理完)`)
} else {
toast.success(`已替换 ${scope}`)
}
}
/**
* 点击 `[[wikilink]]`。
*
* 目标是**库内相对路径**(`名字.md`)—— 与 Rust 侧 `resolve_link` 的「按名字 + 相对
* 当前目录」判据保持一致。找不到就按这个名字在当前笔记所在目录新建一篇:
* 「先写链接、后补内容」是双链笔记的标准用法,静默失败会让这个习惯立刻失效。
*/
async function onWikilink(target: string): Promise<void> {
const name = target.trim()
if (!name) return
const dir = store.currentRelPath.split('/').slice(0, -1).join('/')
const relPath = dir ? `${dir}/${name}.md` : `${name}.md`
if (store.entries.some(entry => entry.relPath === relPath)) {
await store.openNote(relPath)
return
}
try {
await store.createNote(dir, name)
toast.success(`已新建「${name}」`)
} catch (e) {
toast.error(`新建失败:${String(e)}`)
}
}
// ===== 打开库外文件 =====
async function doOpenFile(): Promise<void> {
try {
const selected = await open({
multiple: false,
directory: false,
title: '打开文件',
filters: [
{ name: '文本 / 代码', extensions: ['md', 'txt', 'json', 'yaml', 'yml', 'toml', 'ini', 'log', 'csv'] },
{ name: '全部文件', extensions: ['*'] }
]
})
if (typeof selected !== 'string') return
await store.openFile(selected)
} catch (e) {
toast.error(`打开文件失败:${String(e)}`)
}
}
// ===== 外部改动 =====
const externalConfirmOpen = ref(false)
async function reloadFromExternal(): Promise<void> {
try {
await store.reloadCurrent()
store.externalChange = null
toast.success('已重新载入')
} catch (e) {
toast.error(`重新载入失败:${String(e)}`)
} finally {
externalConfirmOpen.value = false
}
}
/** 「保留我的改动」:只清掉提示,磁盘上的版本仍是外部那份(用户下次保存会覆盖它) */
function keepLocal(): void {
store.externalChange = null
externalConfirmOpen.value = false
}
// ===== 全局按键(窗口级) =====
function onKeydown(event: KeyboardEvent): void {
const mod = event.ctrlKey || event.metaKey
if (!mod) return
const key = event.key.toLowerCase()
if (key === 's') {
event.preventDefault()
void doSave()
} else if (key === 'w') {
// 关闭当前标签(Ctrl+W)
event.preventDefault()
if (store.activeTabId) requestCloseTab(store.activeTabId)
} else if (key === 'tab') {
// 文档间切换(Ctrl+Tab / Ctrl+Shift+Tab)
event.preventDefault()
store.cycleTab(event.shiftKey ? -1 : 1)
} else if (key === 'p' && !event.shiftKey) {
event.preventDefault()
quickOpen.value = true
} else if (key === 'o' && !event.shiftKey) {
event.preventDefault()
void doOpenFile()
} else if (key === 'f') {
// Ctrl+F = 当前文件;Ctrl+Shift+F = 在路径中查找(有目录用目录,否则用笔记库)
event.preventDefault()
openSearch(event.shiftKey ? (searchDir.value ? 'dir' : 'library') : 'file')
} else if (key === 'm' && event.shiftKey) {
event.preventDefault()
store.setViewMode(store.viewMode === 'wysiwyg' ? 'source' : 'wysiwyg')
} else if (key === 'o' && event.shiftKey) {
// 切换右侧抽屉:大纲
event.preventDefault()
drawerMode.value = drawerMode.value === 'outline' ? null : 'outline'
} else if (key === 'b' && event.shiftKey) {
// 切换右侧抽屉:双链
event.preventDefault()
drawerMode.value = drawerMode.value === 'links' ? null : 'links'
} else if (key === 'g' && event.shiftKey) {
// 切换右侧抽屉:双链图谱
event.preventDefault()
drawerMode.value = drawerMode.value === 'graph' ? null : 'graph'
} else if (key === 'n' && event.shiftKey) {
// 与全局快捷键同义:窗口内有焦点时在本窗口直接开对话框,不必绕 Rust 一圈
event.preventDefault()
sidebarVisible.value = true
sidebarRef.value?.showNewNote()
}
}
/** 从 hash 查询串解析初始要打开的文档(`file` = 库内笔记,`path` = 库外文件,`folder` = 本地目录)。 */
function initialTarget(): { relPath: string; path: string; folder: string } {
const hash = window.location.hash
const queryIndex = hash.indexOf('?')
if (queryIndex < 0) return { relPath: '', path: '', folder: '' }
const params = new URLSearchParams(hash.slice(queryIndex + 1))
return {
relPath: params.get('file') ?? '',
path: params.get('path') ?? '',
folder: params.get('folder') ?? ''
}
}
onMounted(async () => {
darkMedia.addEventListener('change', onThemeChange)
window.addEventListener('storage', onStorageChange)
window.addEventListener('keydown', onKeydown, true)
// 检索历史与面板高度来自 localStorage:尽早读取,状态栏按钮与结果面板都要用
searchStore.init()
// 主题 → 显示(窗口是隐藏创建的,这一步之后用户才第一次看到它)
await applyTheme()
try {
await win.show()
await win.setFocus()
} catch (e) {
logger.warn(`显示笔记窗口失败:${String(e)}`)
}
await store.init()
store.setViewMode(store.settings.defaultView === 'source' ? 'source' : 'wysiwyg')
const { relPath: targetRel, path: targetPath, folder: targetFolder } = initialTarget()
if (targetRel) {
await store.openNote(targetRel)
} else if (targetPath) {
try {
await store.openFile(targetPath)
} catch (e) {
toast.error(`打开文件失败:${String(e)}`)
}
} else if (targetFolder) {
sidebarVisible.value = true
sidebarRef.value?.showDirectory()
await store.openFolder(targetFolder).catch(e => toast.error(`打开文件夹失败:${String(e)}`))
} else if (store.hasSession()) {
// 无目标:恢复上次会话(打开的文档 + 光标位置)
await store.restoreSession()
} else if (store.recentFiles.length) {
await store.openDoc(store.recentFiles[0]!.path).catch(() => undefined)
}
})
onBeforeUnmount(() => {
darkMedia.removeEventListener('change', onThemeChange)
window.removeEventListener('storage', onStorageChange)
window.removeEventListener('keydown', onKeydown, true)
if (sessionTimer) {
clearTimeout(sessionTimer)
sessionTimer = null
}
store.saveSession()
store.disposeListeners()
})
// ===== 状态栏 =====
const title = computed(() => store.currentName || '编辑器')
const statusText = computed(() => {
if (store.saving) return '保存中…'
if (store.dirty) return '未保存'
if (!store.hasDocument) return '未打开文档'
return '已保存'
})
/** 编码 / 换行只在库外文件里有意义(笔记永远是 UTF-8 + 换行跟随原文) */
const encodingLabel = computed(() => (store.kind === 'file' ? store.fileDoc?.encoding ?? '' : ''))
const eolLabel = computed(() => {
if (store.kind !== 'file') return ''
return store.fileDoc?.eol === 'crlf' ? 'CRLF' : 'LF'
})
/** 状态栏可切换的编码(值与 `terminal::encoding::normalize` 的规范形态一致)。 */
const ENCODING_OPTIONS = [
{ value: 'utf-8', label: 'UTF-8' },
{ value: 'utf-8-bom', label: 'UTF-8 BOM' },
{ value: 'gb18030', label: 'GB18030' },
{ value: 'gbk', label: 'GBK' },
{ value: 'big5', label: 'Big5' },
{ value: 'shift_jis', label: 'Shift_JIS' },
{ value: 'euc-kr', label: 'EUC-KR' },
{ value: 'latin1', label: 'Latin-1' }
]
// ===== 切换编码(§5.3:有未保存改动时三选一) =====
const encodingDialogOpen = ref(false)
const pendingEncoding = ref('')
/**
* 请求把当前文件按新编码重新解释。
*
* 语义是「换一种方式解释磁盘字节」,因此会从磁盘重新解码并整篇替换内容 ——
* 有未保存改动时必须先让用户选:丢弃 / 先保存 / 取消。
*/
function requestEncoding(encoding: string): void {
if (store.kind !== 'file' || !store.fileDoc) return
if (encoding === store.fileDoc.encoding) return
if (store.dirty) {
pendingEncoding.value = encoding
encodingDialogOpen.value = true
return
}
void store.redecode(encoding).catch(e => toast.error(`切换编码失败:${String(e)}`))
}
async function discardAndRedecode(): Promise<void> {
const encoding = pendingEncoding.value
encodingDialogOpen.value = false
try {
await store.redecode(encoding)
} catch (e) {
toast.error(`切换编码失败:${String(e)}`)
}
}
async function saveThenRedecode(): Promise<void> {
const encoding = pendingEncoding.value
encodingDialogOpen.value = false
try {
// 先按旧编码落盘(用户能立刻看出旧编码是否选错),再按新编码读回
await store.saveCurrent()
await store.redecode(encoding)
} catch (e) {
toast.error(`切换编码失败:${String(e)}`)
}
}
</script>
<template>
<div class="editor-window relative flex h-screen flex-col overflow-hidden text-foreground">
<!-- 自绘标题栏:仅标题区是拖动区,右侧按钮区不是(否则鼠标事件被拖动拦截) -->
<header class="flex h-9 shrink-0 items-center gap-1 border-b border-border px-2">
<!--
这里**不要**再挂 `@mousedown="startDrag"`:`data-tauri-drag-region` 本身已处理
「按住拖动 + 双击最大化/还原」,再手动调一次 `startDragging()` 会让第一次按下
就进入拖动模式,双击的第二下落进拖动里 —— 表现就是「抽搐一下」而不是最大化。
(终端 / 文件窗口同样只靠这个属性。)
-->
<div
class="flex h-full min-w-0 flex-1 items-center gap-2 pl-1"
data-tauri-drag-region
>
<NotebookPen class="size-3.5 shrink-0 text-primary" />
<span class="pointer-events-none truncate text-xs font-medium">{{ title }}</span>
<span v-if="store.dirty" class="size-1.5 shrink-0 rounded-full bg-primary" />
</div>
<div class="w-px h-4 bg-border shrink-0" />
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="doMinimize">
<Minus class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">最小化</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="doToggleMaximize">
<Square class="size-3" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">最大化 / 还原</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button
variant="ghost"
size="icon-sm"
class="hover:!bg-destructive hover:!text-destructive-foreground"
@click="doClose"
>
<X class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">关闭窗口</TooltipContent>
</Tooltip>
</TooltipProvider>
</header>
<!-- 主体:侧栏自导航行起贯通到底;导航行 / 标签栏 / 编辑器同处右侧「编辑列」 -->
<div class="flex min-h-0 flex-1">
<LibrarySidebar v-if="sidebarVisible" ref="sidebarRef" @open="store.openNote($event)" />
<div class="flex min-h-0 min-w-0 flex-1 flex-col">
<!-- 导航行:快捷图标操作行 -->
<EditorToolbar
:apply="applyCommand"
:view-mode="store.viewMode"
:dirty="store.dirty"
:saving="store.saving"
:sidebar-visible="sidebarVisible"
@update:view-mode="store.setViewMode($event)"
@save="doSave"
@open-file="doOpenFile"
@new-file="doNewScratch"
@quick-open="quickOpen = true"
@toggle-sidebar="sidebarVisible = !sidebarVisible"
@nav="onNav"
@open-search="openSearch(searchDir ? 'dir' : 'library')"
/>
<!-- 文档标签栏(多文档) -->
<EditorTabs v-if="store.tabs.length" @close="requestCloseTab" />
<!-- 外部改动提示(有未保存改动时才会出现) -->
<div
v-if="store.externalChange"
class="flex shrink-0 items-center gap-2 border-b border-border bg-warning-soft px-3 py-1.5 text-xs"
>
<AlertTriangle class="size-3.5 shrink-0 text-warning" />
<span class="min-w-0 flex-1 truncate">
该文件已在应用外被
{{ store.externalChange.kind === 'removed' ? '删除' : '修改' }}
—— 你的未保存改动仍在编辑器里
</span>
<Button variant="outline" size="sm" @click="keepLocal">保留我的改动</Button>
<Button variant="outline" size="sm" @click="externalConfirmOpen = true">查看并重载</Button>
</div>
<!-- 大文件降级提示 -->
<div
v-if="store.fileDoc?.large"
class="flex shrink-0 items-center gap-2 border-b border-border bg-muted px-3 py-1 text-[11px] text-muted-foreground"
>
<AlertTriangle class="size-3 shrink-0" />
文件较大,已关闭「所见即所得 / 折叠 / 自动补全」以保证输入流畅
</div>
<!-- 统一搜索栏:横跨编辑列宽度,压在内容上方(IDEA 的 Find 栏位置) -->
<EditorSearch
v-model:open="searchOpen"
v-model:scope="searchScope"
:dir-path="searchDir"
:library-path="libraryPath"
:get-view="getEditorView"
@open-file="onSearchOpenFile"
@replaced="onPathReplaced"
/>
<main 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"
title="未打开文档"
description="从左侧选择一篇笔记、新建一篇,或用 Ctrl+O 打开磁盘上的文件"
:min-height="200"
>
<template #action>
<div class="flex gap-2">
<Button variant="outline" size="sm" @click="sidebarVisible = true">
<PanelLeft class="size-3.5" />打开侧栏
</Button>
<Button variant="outline" size="sm" @click="doOpenFile">打开文件…</Button>
</div>
</template>
</StateBlock>
</div>
<EditorHost
v-show="store.hasDocument"
ref="hostRef"
:is-dark="isDark"
:live-preview="store.viewMode === 'wysiwyg'"
@cursor-moved="onCursorMoved"
@wikilink="onWikilink"
/>
</main>
<!-- 目录 / 库检索结果面板:编辑列底部(IDE 的「Find in Path」工具窗位置) -->
<SearchResultsPanel @open-file="onSearchOpenFile" />
</div>
<!-- 右侧抽屉:大纲 / 双链(描述当前文档,而非「去哪找文件」) -->
<DrawerPanel
v-if="drawerMode"
:mode="drawerMode"
:cursor-line="store.cursorLine"
@update:mode="drawerMode = $event"
@close="drawerMode = null"
@jump="hostRef?.jumpTo($event)"
@open="store.openNote($event)"
/>
</div>
<!-- 状态栏 -->
<footer
class="flex h-7 shrink-0 items-center gap-3 border-t border-border px-3 text-[11px] text-muted-foreground"
>
<span>{{ statusText }}</span>
<span v-if="store.hasDocument" class="tabular-nums">
{{ store.wordCount }} 字 · {{ store.lineCount }} 行
</span>
<span v-if="store.hasDocument" class="tabular-nums">行 {{ store.cursorLine }} : {{ cursorColumn }}</span>
<span v-if="store.hasDocument">语法:{{ store.languageLabel }}</span>
<span
v-if="store.fileDoc?.readonly"
class="rounded-sm bg-warning-soft px-1.5 py-0.5 text-[10px] text-warning"
>
只读
</span>
<template v-if="store.kind === 'file'">
<DropdownMenu>
<DropdownMenuTrigger as-child>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[10px] uppercase transition-colors hover:bg-hover"
title="切换编码(重新解释磁盘字节)"
>
{{ encodingLabel }}
</button>
</DropdownMenuTrigger>
<DropdownMenuContent align="start" class="w-44">
<DropdownMenuLabel>编码</DropdownMenuLabel>
<DropdownMenuItem
v-for="opt in ENCODING_OPTIONS"
:key="opt.value"
@click="requestEncoding(opt.value)"
>
{{ opt.label }}
<span
v-if="store.fileDoc?.encoding === opt.value"
class="ml-auto text-[10px] text-muted-foreground"
>
当前
</span>
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
<DropdownMenu>
<DropdownMenuTrigger as-child>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[10px] transition-colors hover:bg-hover"
title="切换换行(只影响下次保存)"
>
{{ eolLabel }}
</button>
</DropdownMenuTrigger>
<DropdownMenuContent align="start" class="w-32">
<DropdownMenuLabel>换行</DropdownMenuLabel>
<DropdownMenuItem @click="store.setEol('lf')">
LF
<span v-if="store.fileDoc?.eol !== 'crlf'" class="ml-auto text-[10px] text-muted-foreground">当前</span>
</DropdownMenuItem>
<DropdownMenuItem @click="store.setEol('crlf')">
CRLF
<span v-if="store.fileDoc?.eol === 'crlf'" class="ml-auto text-[10px] text-muted-foreground">当前</span>
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
</template>
<!--
目录检索历史:点开底部结果面板(与编码 / 换行同属「状态栏可操作项」分组)。
始终可见而非「有历史才出现」—— 它是结果面板的唯一入口,藏起来用户就找不到
「上次搜了什么」了;没有历史时点开会看到空态说明。
-->
<button
type="button"
class="flex shrink-0 items-center gap-1 rounded-sm px-1.5 py-0.5 transition-colors duration-150 hover:bg-hover hover:text-foreground"
:class="searchStore.panelOpen && 'bg-active text-foreground'"
:title="
searchStore.records.length
? `目录检索历史(${searchStore.records.length} 条)—— 点击开关结果面板`
: '目录检索历史 —— 还没有记录,去搜索栏选「目录」范围搜一次'
"
@click="searchStore.togglePanel()"
>
<History class="size-3" />
<span>检索历史</span>
<span v-if="searchStore.records.length" class="tabular-nums">{{ searchStore.records.length }}</span>
</button>
<span class="ml-auto truncate">{{ store.fileDoc?.path || store.libraryRoot }}</span>
</footer>
<!-- 快速打开(Ctrl+P) -->
<QuickOpen v-model:open="quickOpen" @select="store.openNote($event)" />
<!-- 关闭确认 -->
<ConfirmDialog
v-model:open="closeConfirmOpen"
title="有未保存的改动"
description="关闭窗口会丢失这些改动(自动保存会对未保存内容做最后一次尝试)。"
confirm-text="保存并关闭"
@confirm="forceClose"
/>
<!-- 重载确认 -->
<ConfirmDialog
v-model:open="externalConfirmOpen"
title="重新载入将丢弃未保存的改动"
description="磁盘上的版本会覆盖编辑器里的内容,你当前的改动无法恢复。"
variant="danger"
confirm-text="丢弃并重载"
@confirm="reloadFromExternal"
/>
<!-- 关闭标签确认 -->
<ConfirmDialog
v-model:open="tabCloseConfirmOpen"
title="该标签有未保存的改动"
description="关闭标签会丢失这些改动(选择「保存并关闭」会先保存再关闭)。"
confirm-text="保存并关闭"
@confirm="confirmCloseTab"
/>
<!--
关闭临时草稿:三选一(保存到别处 / 删除 / 取消)。
不用 ConfirmDialog —— 它是「确认 / 取消」两键,而这里必须给出第三条明确出路,
否则用户只能在「丢掉草稿」与「不关标签」之间二选一。
-->
<Dialog :open="scratchCloseOpen" @update:open="scratchCloseOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>关闭临时文件</DialogTitle>
<DialogDescription>
这是一个临时草稿文件,存放在应用数据目录。「保存到别处」会把它另存到你指定的
路径(原临时文件随即删除);「删除」则直接丢弃。
</DialogDescription>
</DialogHeader>
<DialogFooter class="gap-2">
<Button variant="outline" @click="scratchCloseOpen = false">取消</Button>
<Button variant="destructive" @click="discardScratchAndClose">删除</Button>
<Button @click="saveScratchAndClose">保存到别处…</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 切换编码:有未保存改动时三选一(§5.3) -->
<Dialog :open="encodingDialogOpen" @update:open="encodingDialogOpen = $event">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>有未保存的改动</DialogTitle>
</DialogHeader>
<p class="text-xs leading-relaxed text-muted-foreground">
切换编码会以「{{ pendingEncoding }}」重新解释磁盘字节并整篇替换编辑器内容。
当前有未保存的改动,请选择如何处理:
</p>
<DialogFooter class="flex-col gap-2 sm:flex-col sm:space-x-0">
<Button class="w-full" @click="discardAndRedecode">
丢弃我的改动并按新编码重读
</Button>
<Button variant="outline" class="w-full" @click="saveThenRedecode">
先按旧编码保存,再按新编码重读
</Button>
<Button variant="ghost" class="w-full" @click="encodingDialogOpen = false">
取消
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<Toaster />
</div>
</template>
<style scoped>
/* 窗口根容器:mica/acrylic 下透明,普通模式用不透明底色(--popup-bg 由 applyTheme 写入) */
.editor-window {
background: var(--popup-bg, var(--background));
}
</style>
@@ -5,7 +5,7 @@
* # 数据从哪来
*
* 全部来自 SQLite 索引的 `links` 表(写入索引时已把 `[[名字]]` 按 Obsidian 语义
* 「全库按名解析」成库内相对路径)。因此这里不需要扫全库 —— 一次 `notes_backlinks`
* 「全库按名解析」成库内相对路径)。因此这里不需要扫全库 —— 一次 `editor_backlinks`
* 调用就把两侧都取回。
*
* # 未解析链接为什么值得显示
@@ -18,9 +18,9 @@ import { ArrowUpRight, Link2, Link2Off, Loader2, RefreshCw } from '@lucide/vue'
import { toast } from 'vue-sonner'
import { ScrollArea } from '@/components/ui/scroll-area'
import { StateBlock } from '@/components/common'
import { useNotesStore } from '@/stores/notesStore'
import { notesClient } from '../notesClient'
import type { NoteBacklinks, NoteLink } from '@/types/notes'
import { useEditorStore } from '@/stores/editorStore'
import { editorClient } from '../editorClient'
import type { NoteBacklinks, NoteLink } from '@/types/editor'
const props = defineProps<{
/** 当前笔记的库内相对路径(空串 = 没有笔记,面板显示空态) */
@@ -34,7 +34,7 @@ const emit = defineEmits<{
create: [name: string]
}>()
const store = useNotesStore()
const store = useEditorStore()
const data = ref<NoteBacklinks | null>(null)
const loading = ref(false)
@@ -58,7 +58,7 @@ async function load(): Promise<void> {
}
loading.value = true
try {
data.value = await notesClient.backlinks(props.relPath)
data.value = await editorClient.backlinks(props.relPath)
} catch (e) {
// 索引还没建立时这里会失败:不是错误,只是「暂时没有数据」
data.value = null
@@ -0,0 +1,823 @@
<script setup lang="ts">
/**
* 本地目录面板(P3-5 / P5-2):以**懒加载文件树**浏览并操作用户真实文件系统。
*
* 与「笔记库」面板的本质区别:
* - 库是**沙箱**(根目录内、相对路径、走索引);目录是**看盘**(任意路径、
* 绝对路径、不进索引、不做全文检索);
* - 树是**懒加载**的:根 = 打开的文件夹(`store.dirListing`),子目录在展开时才经
* `editor_read_dir` 拉一层并缓存 —— 大目录不再一次全量列举,展开哪层读哪层。
*
* 所有写操作都是**显式动作**,且删除一律走系统回收站(Rust 侧 `editor_delete_path`)。
*
* # 多选与拖拽(P5-2)
*
* 单击保持「进目录(展开/收起)/ 打开文件」;`Ctrl/Cmd+单击` 切换选中、`Shift+单击`
* 范围选中。选中非空时底部出现批量操作条(批量重命名 / 删除所选)。行可拖拽到
* 文件夹行完成移动。
*
* # 结构性操作后的刷新策略
*
* 新建 / 重命名 / 删除 / 移动都会让**已缓存的路径**失真 —— 统一走 `invalidate()`:
* 清空子层缓存 → 重读根 → 并行重读所有已展开目录。展开的目录通常只有几个,代价可忽略;
* 换来的是「缓存里的路径永远有效」这条不变量(拖放目标、选中集都按路径工作)。
*/
import { computed, ref, watch } from 'vue'
import {
AppWindow,
ArrowUp,
ChevronDown,
ChevronRight,
ExternalLink,
FilePlus,
FileText,
Folder,
FolderInput,
FolderOpen,
FolderPlus,
Loader2,
Pencil,
RotateCw,
SquarePen,
Trash2,
X
} 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 {
Dialog,
DialogContent,
DialogFooter,
DialogHeader,
DialogTitle
} from '@/components/ui/dialog'
import { ConfirmDialog, StateBlock } from '@/components/common'
import { useEditorStore } from '@/stores/editorStore'
import { editorClient } from '../editorClient'
import { openEditorWindow } from '../openWindow'
import type { DirEntry } from '@/types/editor'
const store = useEditorStore()
const filter = ref('')
// ===== 懒加载树 =====
/** 树行:条目 + 层级(缩进用) */
interface TreeRow {
entry: DirEntry
depth: number
}
/** 已展开的目录(值 = 该目录的子层已请求/已缓存) */
const expanded = ref<Set<string>>(new Set())
/** 子层缓存:目录绝对路径 → 其子项(Rust 保证目录在前、各自按名排序) */
const childrenMap = ref<Map<string, DirEntry[]>>(new Map())
/** 正在加载子层的目录(行内转圈用) */
const loadingDirs = ref<Set<string>>(new Set())
/** 新建文件 / 文件夹的目标目录(空串 = 根) */
const selectedDir = ref('')
const rootEntries = computed<DirEntry[]>(() => store.dirListing?.entries ?? [])
const rootCwd = computed(() => store.dirListing?.cwd ?? '')
const cwdName = computed(() => {
const cwd = rootCwd.value
if (!cwd) return '本地目录'
return cwd.split(/[\\/]/).filter(Boolean).pop() ?? cwd
})
/** 目录名过滤:命中自身或任一**已加载**后代才可见;过滤时全部按展开渲染。 */
const rows = computed<TreeRow[]>(() => {
const kw = filter.value.trim().toLowerCase()
const out: TreeRow[] = []
const matches = (entry: DirEntry, kids: DirEntry[] | undefined): boolean => {
if (!kw) return true
if (entry.name.toLowerCase().includes(kw)) return true
return (kids ?? []).some(k => matches(k, childrenMap.value.get(k.path)))
}
const walk = (list: DirEntry[], depth: number) => {
for (const entry of list) {
const kids = childrenMap.value.get(entry.path)
if (!matches(entry, kids)) continue
out.push({ entry, depth })
if (entry.kind !== 'dir') continue
const open = expanded.value.has(entry.path) || !!kw
if (open) walk(kids ?? [], depth + 1)
}
}
walk(rootEntries.value, 0)
return out
})
/** 拉取一个目录的子层并写入缓存(已缓存则跳过)。 */
async function loadChildren(path: string): Promise<void> {
if (childrenMap.value.has(path)) return
const loading = new Set(loadingDirs.value)
loading.add(path)
loadingDirs.value = loading
try {
const listing = await editorClient.readDir(path)
const map = new Map(childrenMap.value)
map.set(path, listing.entries)
childrenMap.value = map
} catch (e) {
// 读失败就收起来,别留一个「展开但永远是空的」目录
const next = new Set(expanded.value)
next.delete(path)
expanded.value = next
toast.error(String(e))
} finally {
const done = new Set(loadingDirs.value)
done.delete(path)
loadingDirs.value = done
}
}
function toggleDir(entry: DirEntry): void {
const next = new Set(expanded.value)
if (next.has(entry.path)) {
next.delete(entry.path)
} else {
next.add(entry.path)
selectedDir.value = entry.path
void loadChildren(entry.path)
}
expanded.value = next
}
/**
* 结构性操作后的统一失效:清空缓存 → 重读根 → 并行重读已展开目录。
*
* 「清空缓存」而不是逐个修补:重命名 / 移动会让后代路径整体变化,逐个推导既啰嗦
* 又容易漏;重新拉取已展开的几层是最不容易出错的兜底。
*/
async function invalidate(): Promise<void> {
childrenMap.value = new Map()
await store.readDir(rootCwd.value)
await Promise.all([...expanded.value].map(p => loadChildren(p)))
}
// 换根(打开 / 上一级 / 重新打开):树状态与选择全部重置
watch(
() => store.dirListing?.cwd,
() => {
childrenMap.value = new Map()
expanded.value = new Set()
loadingDirs.value = new Set()
selectedDir.value = ''
filter.value = ''
selected.value = new Set()
lastIndex.value = -1
}
)
// ===== 多选 =====
const selected = ref<Set<string>>(new Set())
const lastIndex = ref(-1)
const allKnown = computed<DirEntry[]>(() => {
const out = [...rootEntries.value]
for (const kids of childrenMap.value.values()) out.push(...kids)
return out
})
const selectedEntries = computed(() => allKnown.value.filter(e => selected.value.has(e.path)))
function toggleSelect(entry: DirEntry): void {
const next = new Set(selected.value)
if (next.has(entry.path)) next.delete(entry.path)
else next.add(entry.path)
selected.value = next
}
function rangeSelect(entry: TreeRow): void {
const list = rows.value
const to = list.findIndex(e => e.entry.path === entry.entry.path)
const from = lastIndex.value >= 0 ? lastIndex.value : to
const [lo, hi] = from <= to ? [from, to] : [to, from]
const next = new Set(selected.value)
for (let i = lo; i <= hi; i++) {
const item = list[i]
if (item) next.add(item.entry.path)
}
selected.value = next
}
// ===== 导航与打开 =====
async function openFolder(): Promise<void> {
try {
await store.openFolderDialog()
} catch (e) {
toast.error(`打开文件夹失败:${String(e)}`)
}
}
/**
* 在已打开文件夹里一键建一个临时文本文件(免命名,建完直接打开)。
*
* 建在**根**下;命名走「`新建文本.txt` → `新建文本 2.txt` → …」:不弹框才叫一键,
* 所以得自己避开重名(用根列表判断占用;真撞上了后端会报错,toast 会带出原因)。
*/
async function createTempFile(): Promise<void> {
const used = new Set(rootEntries.value.map(e => e.name.toLowerCase()))
let name = '新建文本.txt'
for (let i = 2; used.has(name.toLowerCase()) && i < 1000; i++) {
name = `新建文本 ${i}.txt`
}
try {
await createIn(selectedDir.value || rootCwd.value, 'file', name)
toast.success(`已创建 ${name}`)
} catch (e) {
toast.error(`新建文件失败:${String(e)}`)
}
}
async function goUp(): Promise<void> {
const parent = store.dirListing?.parent
if (!parent) return
try {
await store.readDir(parent)
} catch (e) {
toast.error(String(e))
}
}
async function refresh(): Promise<void> {
if (!rootCwd.value) return
try {
await invalidate()
} catch (e) {
toast.error(String(e))
}
}
function openEntry(entry: DirEntry): void {
if (entry.kind === 'dir') {
toggleDir(entry)
} else {
void store.openDoc(entry.path).catch(e => toast.error(`打开失败:${String(e)}`))
}
}
async function openInNewWindow(entry: DirEntry): Promise<void> {
try {
if (entry.kind === 'dir') await openEditorWindow({ folder: entry.path, dedupe: false })
else await openEditorWindow({ path: entry.path, dedupe: false })
} catch (e) {
toast.error(`在新窗口打开失败:${String(e)}`)
}
}
function onRowClick(entry: TreeRow, event: MouseEvent): void {
const index = rows.value.findIndex(e => e.entry.path === entry.entry.path)
if (event.ctrlKey || event.metaKey) {
toggleSelect(entry.entry)
lastIndex.value = index
return
}
if (event.shiftKey) {
rangeSelect(entry)
return
}
if (selected.value.size > 0) selected.value = new Set()
lastIndex.value = index
openEntry(entry.entry)
}
// ===== 拖拽移动 =====
const dragging = ref('')
/** 当前作为放置目标的文件夹路径(高亮用) */
const dropTarget = ref('')
function onDragStart(entry: DirEntry, event: DragEvent): void {
dragging.value = entry.path
event.dataTransfer?.setData('text/plain', entry.path)
if (event.dataTransfer) event.dataTransfer.effectAllowed = 'move'
}
function onDragOver(entry: DirEntry, event: DragEvent): void {
if (entry.kind !== 'dir' || !dragging.value || dragging.value === entry.path) return
event.preventDefault()
if (event.dataTransfer) event.dataTransfer.dropEffect = 'move'
dropTarget.value = entry.path
}
async function onDrop(entry: DirEntry, event: DragEvent): Promise<void> {
event.preventDefault()
const src = dragging.value
dragging.value = ''
dropTarget.value = ''
if (!src || entry.kind !== 'dir' || src === entry.path) return
try {
await editorClient.movePath(src, entry.path)
await invalidate()
} catch (e) {
toast.error(`移动失败:${String(e)}`)
}
}
function onDragEnd(): void {
dragging.value = ''
dropTarget.value = ''
}
// ===== 新建 / 重命名(目标 = 选中的目录,缺省根) =====
type PromptMode = 'file' | 'folder' | 'rename'
const promptOpen = ref(false)
const promptMode = ref<PromptMode>('file')
const promptValue = ref('')
const promptTarget = ref('')
const busy = ref(false)
const promptTitle = computed(() => {
if (promptMode.value === 'file') return '新建文件'
if (promptMode.value === 'folder') return '新建文件夹'
return '重命名'
})
const promptTargetLabel = computed(() => {
if (promptMode.value === 'rename') return ''
const dir = selectedDir.value || rootCwd.value
if (!dir) return ''
const name = dir.split(/[\\/]/).filter(Boolean).pop() ?? dir
return `位置:${name}`
})
function openPrompt(mode: PromptMode, target = '', initial = ''): void {
promptMode.value = mode
promptTarget.value = target
promptValue.value = initial
promptOpen.value = true
}
/** 在指定目录下新建文件 / 文件夹;成功后失效缓存并(文件)打开。 */
async function createIn(dir: string, kind: 'file' | 'folder', name: string): Promise<void> {
if (!dir) return
if (kind === 'file') {
const path = await editorClient.createFile(dir, name)
await invalidate()
await store.recordRecentFile(path, name)
await store.openFile(path)
} else {
await editorClient.createDir(dir, name)
await invalidate()
// 新建的文件夹就地展开,让用户立刻看到它
const next = new Set(expanded.value)
next.add(dir)
expanded.value = next
void loadChildren(dir)
}
}
async function confirmPrompt(): Promise<void> {
const name = promptValue.value.trim()
if (!name) {
toast.error('名称不能为空')
return
}
busy.value = true
try {
if (promptMode.value === 'file') {
await createIn(selectedDir.value || rootCwd.value, 'file', name)
} else if (promptMode.value === 'folder') {
await createIn(selectedDir.value || rootCwd.value, 'folder', name)
} else {
await editorClient.renamePath(promptTarget.value, name)
await invalidate()
}
promptOpen.value = false
} catch (e) {
toast.error(String(e))
} finally {
busy.value = false
}
}
// ===== 批量重命名(模板化) =====
const batchOpen = ref(false)
const batchTemplate = ref('{name}')
const batchBusy = ref(false)
/** 模板占位符:{name} 原名(去扩展名)、{ext} 扩展名(含点)、{n} 序号(1 起) */
function renderTemplate(entry: DirEntry, index: number): string {
const dot = entry.name.lastIndexOf('.')
const stem = dot > 0 ? entry.name.slice(0, dot) : entry.name
const ext = dot > 0 ? entry.name.slice(dot) : ''
return batchTemplate.value
.replace(/\{name\}/g, stem)
.replace(/\{ext\}/g, ext)
.replace(/\{n\}/g, String(index + 1))
}
const batchPreview = computed(() =>
selectedEntries.value.map((entry, index) => ({
entry,
next: renderTemplate(entry, index).trim()
}))
)
function openBatch(): void {
if (!selectedEntries.value.length) return
batchTemplate.value = '{name}'
batchOpen.value = true
}
async function confirmBatch(): Promise<void> {
const items = batchPreview.value
if (items.some(i => !i.next)) {
toast.error('新名称不能为空')
return
}
if (new Set(items.map(i => i.next)).size !== items.length) {
toast.error('新名称存在重复')
return
}
batchBusy.value = true
try {
const failed: string[] = []
for (const item of items) {
try {
await editorClient.renamePath(item.entry.path, item.next)
} catch (e) {
failed.push(`${item.next}:${String(e)}`)
}
}
await invalidate()
if (failed.length) toast.error(`部分失败:${failed.join(';')}`)
else toast.success(`已重命名 ${items.length} 项`)
batchOpen.value = false
selected.value = new Set()
} catch (e) {
toast.error(String(e))
} finally {
batchBusy.value = false
}
}
// ===== 删除 =====
const confirmOpen = ref(false)
const deleteTargets = ref<DirEntry[]>([])
function askDelete(list: DirEntry[]): void {
if (!list.length) return
deleteTargets.value = list
confirmOpen.value = true
}
async function doDelete(): Promise<void> {
const list = deleteTargets.value
if (!list.length) return
try {
const report = await editorClient.deletePath(list.map(e => e.path))
await invalidate()
if (report.removed > 0) toast.success(`已移入回收站 ${report.removed} 项`)
if (report.failed.length) toast.error(report.failed.join(';'))
selected.value = new Set()
} catch (e) {
toast.error(String(e))
} finally {
confirmOpen.value = false
deleteTargets.value = []
}
}
// ===== 右键菜单(行内 4 个按钮改到这里) =====
const menuOpen = ref(false)
const menuX = ref(0)
const menuY = ref(0)
const menuEntry = ref<DirEntry | null>(null)
/** 菜单项数(用于贴边翻转时的预估高度) */
const MENU_ITEMS = 6
const MENU_WIDTH = 184
/** 右键打开菜单;若该行不在选中集内,则把选中集改为「仅它」。 */
function openMenu(event: MouseEvent, entry: DirEntry): void {
if (!selected.value.has(entry.path)) selected.value = new Set([entry.path])
menuEntry.value = entry
const height = MENU_ITEMS * 28 + 16
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 - height - 8))
menuOpen.value = true
}
function closeMenu(): void {
menuOpen.value = false
menuEntry.value = null
}
/** 删除目标:右键行在选中集内时删整批,否则只删它。 */
const menuDeleteTargets = computed<DirEntry[]>(() => {
const entry = menuEntry.value
if (!entry) return []
return selected.value.has(entry.path) ? selectedEntries.value : [entry]
})
function menuOpenEntry(): void {
const entry = menuEntry.value
closeMenu()
if (entry) openEntry(entry)
}
function menuNewWindow(): void {
const entry = menuEntry.value
closeMenu()
if (entry) void openInNewWindow(entry)
}
function menuReveal(): void {
const entry = menuEntry.value
closeMenu()
if (entry) store.revealPath(entry.path)
}
function menuRename(): void {
const entry = menuEntry.value
closeMenu()
if (entry) openPrompt('rename', entry.path, entry.name)
}
function menuDelete(): void {
const targets = menuDeleteTargets.value
closeMenu()
askDelete(targets)
}
// 不默认加载主目录:默认态就是「打开文件夹」入口,由用户显式选择
</script>
<template>
<div class="flex h-full min-h-0 flex-col">
<!-- 默认态:尚未打开任何文件夹时,面板本身就是一个「打开文件夹」入口 -->
<div v-if="!store.dirListing" class="flex min-h-0 flex-1 items-center justify-center">
<StateBlock
variant="empty"
title="未打开文件夹"
description="选择一个本地文件夹后,可在其中浏览、打开与编辑文件"
:min-height="180"
>
<template #action>
<Button size="sm" @click="openFolder">
<FolderOpen class="size-3.5" />打开文件夹
</Button>
</template>
</StateBlock>
</div>
<!-- 工具条:上一级 / 刷新 / 打开文件夹 -->
<div v-if="store.dirListing" class="flex h-8 shrink-0 items-center gap-0.5 px-2">
<Button
variant="ghost"
size="icon-sm"
title="上一级"
:disabled="!store.dirListing?.parent"
@click="goUp"
>
<ArrowUp class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
:title="store.dirLoading ? '正在读取…' : '刷新'"
:disabled="store.dirLoading"
@click="refresh"
>
<RotateCw class="size-3.5" :class="store.dirLoading && 'animate-spin'" />
</Button>
<span class="ml-1 truncate text-[11px] font-medium text-fg-secondary" :title="store.dirListing?.cwd">
{{ cwdName }}
</span>
<div class="ml-auto flex items-center gap-0.5">
<Button variant="ghost" size="icon-sm" title="新建文件(在选中的目录 / 根)" @click="openPrompt('file')">
<FilePlus class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="新建文件夹(在选中的目录 / 根)" @click="openPrompt('folder')">
<FolderPlus class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="新建临时文本文件(一键创建,不弹命名框)"
:disabled="store.dirLoading"
@click="createTempFile"
>
<SquarePen class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="打开文件夹…" @click="openFolder">
<FolderOpen class="size-3.5" />
</Button>
</div>
</div>
<!-- 过滤 -->
<div v-if="store.dirListing" class="shrink-0 px-2 pb-2">
<div class="relative">
<Input v-model="filter" placeholder="按名称过滤…" class="h-7 pr-6 text-[11px]" />
<button
v-if="filter"
type="button"
class="absolute top-1/2 right-1.5 -translate-y-1/2 text-muted-foreground hover:text-foreground"
@click="filter = ''"
>
<X class="size-3" />
</button>
</div>
</div>
<!-- 树 -->
<ScrollArea v-if="store.dirListing" class="min-h-0 flex-1">
<div 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>
</div>
<StateBlock
v-else-if="!rows.length"
variant="empty"
:title="filter ? '没有匹配项' : '空目录'"
:description="filter ? undefined : '换个目录,或点右上角打开一个文件夹'"
:min-height="140"
/>
<template v-else>
<div
v-for="row in rows"
:key="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
? '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'
]"
:style="{ paddingLeft: `${row.depth * 12 + 4}px` }"
:title="row.entry.path"
draggable="true"
@dragstart="onDragStart(row.entry, $event)"
@dragover="onDragOver(row.entry, $event)"
@drop="onDrop(row.entry, $event)"
@dragend="onDragEnd"
@click="onRowClick(row, $event)"
@contextmenu.prevent="openMenu($event, row.entry)"
>
<!-- 目录行:展开箭头(懒加载不转圈 —— 目录树展开是高频动作,闪烁比等待更烦)
文件行:占位对齐 + 文件图标 -->
<template v-if="row.entry.kind === 'dir'">
<component
:is="expanded.has(row.entry.path) ? ChevronDown : ChevronRight"
class="size-3.5 shrink-0 opacity-70"
/>
<Folder class="size-3.5 shrink-0 opacity-80" />
</template>
<template v-else>
<span class="w-3.5 shrink-0" />
<FileText class="size-3.5 shrink-0 opacity-70" />
</template>
<span class="truncate text-xs">{{ row.entry.name }}</span>
</div>
</template>
</div>
</ScrollArea>
<!-- 批量操作条(有选中时) -->
<div
v-if="store.dirListing && selected.size"
class="flex h-8 shrink-0 items-center gap-1 border-t border-border px-2 text-[11px] text-muted-foreground"
>
<span class="tabular-nums">已选 {{ selected.size }} 项</span>
<div class="ml-auto flex items-center gap-1">
<Button variant="outline" size="sm" @click="openBatch">
<FolderInput class="size-3.5" />批量重命名
</Button>
<Button variant="outline" size="sm" @click="askDelete(selectedEntries)">
<Trash2 class="size-3.5" />删除
</Button>
<Button variant="ghost" size="icon-sm" title="取消选择" @click="selected = new Set()">
<X class="size-3.5" />
</Button>
</div>
</div>
<!-- 右键菜单:文件行的操作(原行内 4 个按钮移到这里) -->
<template v-if="menuOpen && menuEntry">
<div class="fixed inset-0 z-40" @click="closeMenu" @contextmenu.prevent="closeMenu" />
<div
class="fixed z-50 min-w-[184px] overflow-hidden rounded-md border border-border bg-card py-1 text-xs text-foreground shadow-md"
:style="{ left: `${menuX}px`, top: `${menuY}px` }"
>
<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="menuOpenEntry"
>
<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="menuNewWindow"
>
<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="menuReveal"
>
<ExternalLink 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="menuRename"
>
<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="menuDelete"
>
<Trash2 class="size-3.5 opacity-70" />
删除{{ menuDeleteTargets.length > 1 ? ` (${menuDeleteTargets.length})` : '' }}
</button>
</div>
</template>
<!-- 名称输入 -->
<Dialog :open="promptOpen" @update:open="promptOpen = $event">
<DialogContent class="sm:max-w-sm">
<DialogHeader>
<DialogTitle>{{ promptTitle }}</DialogTitle>
</DialogHeader>
<Input
v-model="promptValue"
:placeholder="promptMode === 'rename' ? '新名称' : '名称'"
@keydown.enter="confirmPrompt"
/>
<p v-if="promptTargetLabel" class="text-[11px] text-muted-foreground">{{ promptTargetLabel }}</p>
<DialogFooter>
<Button variant="outline" :disabled="busy" @click="promptOpen = false">取消</Button>
<Button :disabled="busy" @click="confirmPrompt">确定</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 批量重命名 -->
<Dialog :open="batchOpen" @update:open="batchOpen = $event">
<DialogContent class="sm:max-w-lg">
<DialogHeader>
<DialogTitle>批量重命名({{ selectedEntries.length }} 项)</DialogTitle>
</DialogHeader>
<div class="flex flex-col gap-2">
<Input v-model="batchTemplate" placeholder="名称模板" />
<p class="text-[11px] text-muted-foreground">
占位符:<code class="font-mono">{name}</code> 原名 ·
<code class="font-mono">{ext}</code> 扩展名 ·
<code class="font-mono">{n}</code> 序号
</p>
<ScrollArea class="max-h-60 rounded-sm border border-border">
<div class="divide-y divide-divider">
<div
v-for="item in batchPreview"
:key="item.entry.path"
class="flex items-center gap-2 px-2 py-1 text-xs"
>
<span class="min-w-0 flex-1 truncate text-fg-secondary">{{ item.entry.name }}</span>
<span class="shrink-0 text-muted-foreground">→</span>
<span class="min-w-0 flex-1 truncate text-foreground">{{ item.next || '(空)' }}</span>
</div>
</div>
</ScrollArea>
</div>
<DialogFooter>
<Button variant="outline" :disabled="batchBusy" @click="batchOpen = false">取消</Button>
<Button :disabled="batchBusy" @click="confirmBatch">重命名</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<!-- 删除确认(走回收站) -->
<ConfirmDialog
v-model:open="confirmOpen"
title="删除确认"
variant="danger"
confirm-text="移入回收站"
:description="
deleteTargets.length > 1
? `将把选中的 ${deleteTargets.length} 项移入系统回收站(不是永久删除)。`
: `将把「${deleteTargets[0]?.name}」移入系统回收站(不是永久删除)。`
"
@confirm="doDelete"
/>
</div>
</template>
@@ -0,0 +1,73 @@
<script setup lang="ts">
/**
* 编辑区右侧抽屉(P3-4):承载「大纲 / 双链」。
*
* 为什么把它们从侧栏挪出来:侧栏描述的是「去哪找文件」,而大纲与双链描述的是
* **当前文档**。混在一起会让侧栏在「导航」与「文档信息」两种语义之间摇摆。
*/
import { Link2, ListTree, Share2, X } from '@lucide/vue'
import { Button } from '@/components/ui/button'
import { SegmentedNav } from '@/components/common'
import MarkdownOutline from './MarkdownOutline.vue'
import BacklinksPanel from './BacklinksPanel.vue'
import LinkGraph from './LinkGraph.vue'
import { useEditorStore } from '@/stores/editorStore'
const props = defineProps<{
mode: 'outline' | 'links' | 'graph'
/** 编辑器当前光标行(大纲高亮用) */
cursorLine: number
}>()
const emit = defineEmits<{
'update:mode': [mode: 'outline' | 'links' | 'graph']
close: []
jump: [from: number]
open: [relPath: string]
create: []
}>()
const store = useEditorStore()
const NAV_ITEMS = [
{ value: 'outline', label: '大纲', icon: ListTree },
{ value: 'links', label: '双链', icon: Link2 },
{ value: 'graph', label: '图谱', icon: Share2 }
]
function setMode(mode: string): void {
if (mode === 'links' || mode === 'graph') emit('update:mode', mode)
else emit('update:mode', 'outline')
}
</script>
<template>
<aside class="flex h-full min-h-0 w-64 shrink-0 flex-col border-l border-border">
<div class="flex h-11 shrink-0 items-center gap-1 border-b border-border px-2">
<SegmentedNav
:model-value="props.mode"
:items="NAV_ITEMS"
block
@update:model-value="setMode"
/>
<Button variant="ghost" size="icon-sm" title="关闭抽屉" @click="emit('close')">
<X class="size-3.5" />
</Button>
</div>
<MarkdownOutline
v-if="props.mode === 'outline'"
class="min-h-0 flex-1"
:cursor-line="props.cursorLine"
@jump="emit('jump', $event)"
/>
<BacklinksPanel
v-else-if="props.mode === 'links'"
class="min-h-0 flex-1"
:rel-path="store.currentRelPath"
@open="emit('open', $event)"
@create="emit('create')"
/>
<LinkGraph v-else class="min-h-0 flex-1" @open="emit('open', $event)" />
</aside>
</template>
@@ -23,9 +23,9 @@
* `store.language`(一个 thunk),拿到后就地 `setLanguageExtension`;
* 旧语言的过期结果由 store 里的令牌机制丢弃,这里不需要再判一次。
*/
import { onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { EditorView } from '@codemirror/view'
import { useNotesStore } from '@/stores/notesStore'
import { useEditorStore } from '@/stores/editorStore'
import {
createEditorState,
jumpToPosition,
@@ -34,10 +34,11 @@ import {
setLanguageExtension,
type EditorConfig
} from '../editor/core'
import { editorBackground } from '../editor/themes'
import { createLogger } from '@/lib/logger'
import type { Extension } from '@codemirror/state'
const logger = createLogger('notes')
const logger = createLogger('editor')
const props = defineProps<{
/** 应用当前是否深色(跟随应用主题时用于取深/浅变体) */
@@ -53,9 +54,19 @@ const emit = defineEmits<{
'wikilink': [target: string]
}>()
const store = useNotesStore()
const store = useEditorStore()
const hostRef = ref<HTMLDivElement | null>(null)
/**
* 编辑器外壳底色:跟随当前**实际生效**的主题。
*
* CM6 只会绘制 `.cm-editor` 覆盖到的区域,正文下方留白等仍由外壳容器显示;
* 若外壳透明就会透出窗口的 mica 背景(表现为「编辑器背景是透明的」)。
*/
const hostBackground = computed(() =>
editorBackground(String(store.settings.editorTheme), store.settings.followAppTheme, props.isDark)
)
let view: EditorView | null = null
let autosaveTimer: ReturnType<typeof setTimeout> | null = null
/** 程序化替换文档期间抑制「变更 → 置脏」 */
@@ -158,8 +169,17 @@ watch(
}
if (appliedRevision === store.docRevision) return
appliedRevision = store.docRevision
// 目标光标行要在 replaceDoc **之前**取:替换会派发 selection 变化,
// updateListener 随即把 store.cursorLine 覆盖成 1,之后再读就只剩第 1 行了。
const restoreLine = store.cursorLine
applyingDoc = true
replaceDoc(view, store.content)
// 标签切换 / 会话恢复:按 store.cursorLine 复位光标(默认第 1 行不动)
if (restoreLine > 1) {
const line = Math.min(restoreLine, view.state.doc.lines)
const pos = view.state.doc.line(line).from
view.dispatch({ selection: { anchor: pos }, scrollIntoView: false })
}
applyingDoc = false
void applyLanguage(++languageSeq)
}
@@ -218,28 +238,80 @@ defineExpose({
/** 大纲点击跳转 */
jumpTo: (position: number) => {
if (view) jumpToPosition(view, position)
},
/**
* 跳转到某行某列(统一搜索器的「在目录 / 库中查找」结果点击用)。
*
* 行号可能来自**稍早的**检索结果,用户在此期间可能已编辑 —— 越界一律夹到文档
* 范围内(同 `jumpToPosition` 的取舍:跳到近似位置好过整块报错)。
*/
jumpToLine: (line: number, column = 1) => {
if (!view) return
const total = view.state.doc.lines
const number = Math.max(1, Math.min(Math.floor(line), total))
const info = view.state.doc.line(number)
const anchor = Math.min(info.to, info.from + Math.max(0, column - 1))
view.dispatch({ selection: { anchor }, scrollIntoView: true })
view.focus()
}
})
</script>
<template>
<div ref="hostRef" class="notes-editor-host h-full min-h-0 overflow-hidden" />
<div
ref="hostRef"
class="editor-host h-full min-h-0 overflow-hidden"
:style="{ background: hostBackground }"
/>
</template>
<style scoped>
.notes-editor-host :deep(.cm-editor) {
.editor-host :deep(.cm-editor) {
height: 100%;
background: transparent;
/* 不写 background: transparent —— 让 CM6 主题自己的底色生效(见 themes.ts) */
}
.notes-editor-host :deep(.cm-scroller) {
.editor-host :deep(.cm-scroller) {
padding: 12px 8px 32px;
overflow: auto;
/* 滚动条与项目 ScrollArea 一致:细轨 + 圆角 thumb(同终端 xterm 的做法) */
scrollbar-width: thin;
scrollbar-color: var(--border) transparent;
}
.notes-editor-host :deep(.cm-editor.cm-focused) {
.editor-host :deep(.cm-scroller)::-webkit-scrollbar {
width: 10px;
height: 10px;
}
.editor-host :deep(.cm-scroller)::-webkit-scrollbar-track {
background: transparent;
}
.editor-host :deep(.cm-scroller)::-webkit-scrollbar-thumb {
background: var(--border);
border: 3px solid transparent;
border-radius: 9999px;
background-clip: padding-box;
}
.editor-host :deep(.cm-scroller)::-webkit-scrollbar-thumb:hover {
background: var(--muted-foreground);
background-clip: padding-box;
}
.editor-host :deep(.cm-scroller)::-webkit-scrollbar-corner {
background: transparent;
}
.editor-host :deep(.cm-editor.cm-focused) {
outline: none;
}
/* 统一搜索器的命中高亮:改用应用语义色,而不是 @codemirror/search 自带的黄/橙
—— 自带色在浅色主题下几乎看不见,也与应用观感割裂 */
.editor-host :deep(.cm-searchMatch) {
background: color-mix(in srgb, var(--primary) 26%, transparent);
outline: none;
border-radius: 2px;
}
.editor-host :deep(.cm-searchMatch.cm-searchMatch-selected) {
background: color-mix(in srgb, var(--primary) 55%, transparent);
}
/* 笔记正文里正文与标题之间留些气口,Live Preview 下更接近阅读视图 */
.notes-editor-host :deep(.cm-content) {
.editor-host :deep(.cm-content) {
padding-bottom: 24vh;
}
</style>
@@ -0,0 +1,879 @@
<script setup lang="ts">
/**
* 统一搜索器(Find / Replace,IDEA 风格浮动卡片)。
*
* # 为什么要把「编辑器自带查找」与「笔记库检索」合到这里
*
* 原来有两套搜索:CM6 自带面板(只能查当前文件)与侧栏 FTS5 索引检索(只能查笔记库,
* 只有片段没有行号、不支持正则)。用户要在两者之间来回切换,且都不能「在当前目录里
* 搜一段正则」。这里把三者收进**一个**输入区,用「范围」切换:
*
* ```text
* 当前文件 → CM6 search API(实时高亮 + N/M + 替换)
* 目录 → Rust 逐行 grep + 批量替换,结果落到**底部结果面板**
* 笔记库 → 同一个 grep,检索根换成库根
* ```
*
* # 为什么是横跨编辑列的条(而不是悬浮小卡片)
*
* 照 IDEA 的 Find 栏:横跨编辑区宽度、压在内容上方、不遮挡正文。窄卡片会把长目录路径
* 与过滤条件挤成一行放不下,横条则能从容分行排布。
*
* # 结果为什么不在这里显示
*
* 结果列表搬到了编辑列底部的 `SearchResultsPanel`:卡片宽度有限(预览截断得厉害),
* 而且卡片一关结果就没了 —— 但「先搜完、再逐条点开看」才是这个功能的真实用法。
* 因此卡片只负责**发起检索**,结果 / 历史 / 面板开关都归 `editorSearchStore`。
*
* # 为什么两种范围的行为不同
*
* - 当前文件是**内存里的字符串**,边打字边搜没有成本 → 防抖 120ms 实时搜;
* - 当前目录 / 笔记库是**磁盘扫描** → 只在回车 / 点搜索时执行一次,绝不边打字边扫盘。
*
* # 关键词从选中文本来
*
* `Ctrl+F` 打开时把**当前选中的文本**填进关键词(IDEA / VS Code 行为);跨行选区不算,
* 见 `prefillFromSelection`。
*
* # 目录范围的替换是破坏性的
*
* 目录 / 笔记库的「全部替换」会**直接改写磁盘文件**:它走 Rust 的批量替换,而不是编辑器
* 缓冲区。因此必须先过确认框,后端按每个文件的原编码写回,并把跳过的文件逐个回报
* (见 `grep.rs::replace_in_path`)。
*
* # 检索条件(目录 / 库范围)
*
* - **检索只在回车 / 点搜索按钮时发起**:切范围、改目录、改过滤、点历史条目都**只改
* 条件不搜**。磁盘扫描既慢又不知道什么时候来的结果,必须由一个明确动作触发;
* - **目录**:可自由输入的输入框(默认侧栏打开的目录 / 当前文件所在目录),右侧图标
* 打开系统选择器;
* - **文件类型 / 跳过目录**(**仅目录范围**):各带一个开关与输入框(`|` 或 `,` 分隔)。
* 跳过目录清单是后端**唯一**的跳过依据,所以清空它就会连 `node_modules` 一起搜 ——
* 这是用户明确要求时才会做的事。笔记库范围不暴露这两个条件(见 `pathFilters`);
* - 关键词 / 替换串 / 目录 / 类型 / 跳过目录都带**图标历史**(见 `SearchHistoryInput`):
* 点输入框右侧的历史图标才展开,聚焦不打断输入。点历史只填值。这组历史是
* 「刚输入过什么」,与结果面板里那份「检索记录」(按条件重跑)是两回事。
*
* # 编码
*
* 目录 / 库范围**不假设 UTF-8**:后端按每个文件自己的编码解码(预览即原文),替换也按
* 原编码写回。编码装不下替换内容的文件会被跳过并列出,绝不做有损写入。
*
* # Esc 关闭
*
* `Esc` 由根节点统一接管(`@keydown.esc`):搜索栏里有七八个输入框与按钮,逐个挂
* 处理器既啰嗦又容易漏 —— 而「Esc 关掉搜索栏」在哪个控件上按都该成立。事件从子控件
* 冒泡到根节点即可覆盖全部。
*
* # 为什么高亮不用 v-html
*
* 结果预览来自用户文件正文,`v-html` 是自找的 XSS 面。Rust 回传的是命中下标,
* 底部结果面板用 `pieces()` 切成「普通 / 命中」两段文本,永远走插值渲染。
*/
import { computed, nextTick, reactive, ref, watch } from 'vue'
import {
CaseSensitive,
ChevronDown,
ChevronRight,
ChevronUp,
FileType,
FolderOpen,
FolderX,
Loader2,
Regex,
ReplaceAll,
RotateCcw,
Search,
WholeWord,
X
} from '@lucide/vue'
// 别名:`open` 与本组件的 `open` prop 同名,会和模板里的绑定撞名
import { open as openDialog } from '@tauri-apps/plugin-dialog'
import type { EditorView } from '@codemirror/view'
import {
SearchQuery,
replaceAll as cmReplaceAll,
replaceNext as cmReplaceNext,
setSearchQuery
} from '@codemirror/search'
import { Button } from '@/components/ui/button'
import { ConfirmDialog } from '@/components/common'
import { editorClient } from '../editorClient'
import SearchHistoryInput from './SearchHistoryInput.vue'
import { useEditorSearchStore } from '@/stores/editorSearchStore'
import type { PathReplaceResult } from '@/types/editor'
/** 搜索范围:当前文件 / 当前目录 / 笔记库 */
export type SearchScope = 'file' | 'dir' | 'library'
const props = defineProps<{
/** 卡片是否可见 */
open: boolean
scope: SearchScope
/** 「当前目录」的检索根(绝对路径;空串 = 无可用目录) */
dirPath: string
/** 笔记库根(绝对路径;空串 = 尚未设置库) */
libraryPath: string
/** 取当前 CM6 视图(未打开文档时为 null) */
getView: () => EditorView | null
}>()
const emit = defineEmits<{
'update:open': [value: boolean]
'update:scope': [value: SearchScope]
/** 结果点击:打开文件并跳到某行某列 */
'open-file': [payload: { path: string; line: number; column: number }]
/** 目录 / 库的批量替换已完成(磁盘文件已被改写,调用方需要重载当前文档) */
replaced: [result: PathReplaceResult]
}>()
const isFile = computed(() => props.scope === 'file')
/**
* 用户显式指定的检索目录(`null` = 用默认:侧栏打开的目录 / 当前文件所在目录)。
*
* 只存在组件内存里,不落设置:它是「这一次想在哪找」的临时意图,不该在下次开窗口时
* 悄悄把范围指回某个旧目录。卡片关掉再打开会保留(组件不卸载),符合「刚选过」的预期。
*/
const customDir = ref<string | null>(null)
/**
* 「目录」范围实际用的检索根:用户手填 / 选过的优先,否则用默认(侧栏打开的目录 /
* 当前文件所在目录)。
*
* 用 `??` 而不是 `||` —— 用户把输入框清空是**有效状态**(会提示「请指定检索目录」),
* 不该被当成「没填」而悄悄回落到默认值。
*/
const dirRoot = computed(() => customDir.value ?? props.dirPath)
/** 目录输入框的绑定:读时回落默认值,写时记成「用户指定的目录」。 */
const dirValue = computed({
get: () => dirRoot.value,
set: value => {
customDir.value = value
}
})
/** 检索根(目录 / 笔记库) */
const activeDir = computed(() => (props.scope === 'dir' ? dirRoot.value : props.libraryPath))
// ===== 输入与选项 =====
const pattern = ref('')
const replaceText = ref('')
const showReplace = ref(false)
const caseSensitive = ref(false)
const wholeWord = ref(false)
const regex = ref(false)
/**
* 文件类型默认值:`*.*` = 全部文件(Windows 习惯)。后端也把 `*` / `*.*` 当「全部」
* 处理,否则无扩展名的 `Makefile` 会被默认值意外排除。
*/
const DEFAULT_FILE_TYPES = '*.*'
/**
* 跳过目录名默认值。
*
* **必须与 Rust `grep.rs::DEFAULT_SKIP_DIRS` 一致** —— 这里是展示源(用户看到的初值),
* 那边是字段缺省时的兜底。后端已不再无条件跳过点目录,清单是唯一依据。
*/
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'
/** 文件类型过滤开关(关掉 = 不按类型过滤,等于全部文件) */
const useFileTypes = ref(true)
const fileTypes = ref(DEFAULT_FILE_TYPES)
/** 跳过目录开关(关掉 = 不跳过任何目录,连 node_modules 一起搜) */
const useSkipDirs = ref(true)
const skipDirs = ref(DEFAULT_SKIP_DIRS)
// ===== 历史记录 =====
//
// 落 localStorage 而不是模块设置:这是搜索卡片自己的「用过什么」,跨窗口共享、重启后
// 还在(与编辑器会话同一姿态),但不需要进 settings.json 受设置版本迁移管。
const HISTORY_KEY = 'thing_editor_search_history'
/** 每组历史最多留多少条 */
const HISTORY_MAX = 20
interface SearchHistory {
pattern: string[]
replace: string[]
dir: string[]
fileTypes: string[]
skipDirs: string[]
}
function emptyHistory(): SearchHistory {
return { pattern: [], replace: [], dir: [], fileTypes: [], skipDirs: [] }
}
function loadHistory(): SearchHistory {
const base = emptyHistory()
try {
const raw = localStorage.getItem(HISTORY_KEY)
if (!raw) return base
const parsed = JSON.parse(raw) as Partial<SearchHistory>
for (const key of Object.keys(base) as Array<keyof SearchHistory>) {
const value = parsed[key]
if (Array.isArray(value)) {
base[key] = value.filter(v => typeof v === 'string' && v.trim()).slice(0, HISTORY_MAX)
}
}
} catch {
/* 坏数据一律当空历史,不影响搜索 */
}
return base
}
const history = reactive<SearchHistory>(loadHistory())
function saveHistory(): void {
try {
localStorage.setItem(HISTORY_KEY, JSON.stringify(history))
} catch {
/* 忽略存储失败 */
}
}
/** 记一条历史(去重 + 置顶 + 限量)。空串不记。 */
function remember(key: keyof SearchHistory, value: string): void {
const text = value.trim()
if (!text) return
history[key] = [text, ...history[key].filter(item => item !== text)].slice(0, HISTORY_MAX)
saveHistory()
}
function forget(key: keyof SearchHistory, value: string): void {
history[key] = history[key].filter(item => item !== value)
saveHistory()
}
function clearHistory(key: keyof SearchHistory): void {
history[key] = []
saveHistory()
}
// ===== 当前文件范围 =====
const matchCount = ref(0)
const currentMatch = ref(0)
/** 命中的字符区间(用于上一个 / 下一个导航) */
let fileMatches: Array<{ from: number; to: number }> = []
// ===== 目录 / 笔记库范围 =====
//
// 状态(结果 / 历史 / 底部面板)都在 `editorSearchStore` 里:结果面板与状态栏按钮也要
// 读它,而这个卡片一关(`v-if`)本地 state 就没了 —— 面板却还得继续显示上次的结果。
const searchStore = useEditorSearchStore()
const results = computed(() => searchStore.results)
const searching = computed(() => searchStore.searching)
const patternRef = ref<InstanceType<typeof SearchHistoryInput> | null>(null)
const scopeHint = computed(() => {
if (props.scope === 'file') return ''
if (props.scope === 'library') return props.libraryPath || '尚未设置笔记库'
return dirRoot.value || '请指定检索目录'
})
/**
* Ctrl+F 打开时用**当前选中的文本**填关键词(IDEA / VS Code 的行为)。
*
* 只取「非空且不跨行」的选区:跨行片段当关键词没有意义 —— 当前文件里换行只是字面量,
* 磁盘 grep 又是逐行匹配的,拿一整段代码当搜索词只会得到 0 命中。此时沿用上一次的
* 关键词,由调用方在输入框里全选,方便直接覆盖输入。
*/
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
pattern.value = text
}
// ===== 当前文件:CM6 search API =====
function buildQuery(): SearchQuery {
return new SearchQuery({
search: pattern.value,
caseSensitive: caseSensitive.value,
regexp: regex.value,
wholeWord: wholeWord.value,
replace: replaceText.value
})
}
/** 清掉编辑器里的命中高亮(关闭卡片 / 清空关键词时)。 */
function clearFileHighlights(): void {
const view = props.getView()
if (!view) return
view.dispatch({ effects: setSearchQuery.of(new SearchQuery({ search: '' })) })
matchCount.value = 0
currentMatch.value = 0
fileMatches = []
}
/** 选中第 index 处命中(0 起)并滚动到可见。 */
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
})
}
function runFileSearch(): void {
const view = props.getView()
if (!view) {
clearFileHighlights()
return
}
const query = buildQuery()
if (!query.valid) {
// 空关键词或非法正则:清掉高亮,但不弹错(用户还在输入过程中)
view.dispatch({ effects: setSearchQuery.of(new SearchQuery({ search: '' })) })
matchCount.value = 0
currentMatch.value = 0
fileMatches = []
return
}
// 先把查询写进编辑器状态(高亮随之渲染),再自行枚举命中做 N/M 与导航
view.dispatch({ effects: setSearchQuery.of(query) })
const collected: Array<{ from: number; to: number }> = []
const cursor = query.getCursor(view.state)
for (let step = cursor.next(); !step.done; step = cursor.next()) {
collected.push(step.value)
// 上限只是防止病态文档把枚举拖死;正常文档远达不到
if (collected.length >= 20000) break
}
fileMatches = collected
matchCount.value = collected.length
if (!collected.length) {
currentMatch.value = 0
return
}
// 落到「当前选区起点之后的第一处」,没有则回到第一处(同 IDEA 的落点规则)
const from = view.state.selection.main.from
let index = collected.findIndex(range => range.from >= from)
if (index < 0) index = 0
currentMatch.value = index + 1
selectMatch(index)
}
/** 上一个 / 下一个(循环)。 */
function stepFile(delta: number): void {
const total = matchCount.value
if (!total) return
let index = currentMatch.value - 1
if (index < 0) index = delta > 0 ? -1 : 0
index = (index + delta + total) % total
currentMatch.value = index + 1
selectMatch(index)
}
/** 替换当前命中。 */
function replaceCurrent(): void {
const view = props.getView()
if (!view || !pattern.value) return
remember('replace', replaceText.value)
view.dispatch({ effects: setSearchQuery.of(buildQuery()) })
cmReplaceNext(view)
runFileSearch()
}
/** 全部替换。 */
function replaceAll(): void {
const view = props.getView()
if (!view || !pattern.value) return
remember('replace', replaceText.value)
view.dispatch({ effects: setSearchQuery.of(buildQuery()) })
cmReplaceAll(view)
runFileSearch()
}
// ===== 当前目录 / 笔记库:Rust 逐行 grep =====
/** 选一个目录作为「目录」范围的检索根。 */
async function pickDir(): Promise<void> {
const selected = await openDialog({ directory: true, multiple: false, title: '选择检索目录' })
if (typeof selected !== 'string') return
customDir.value = selected
// 只改条件,不顺手搜一次:检索一律由「回车 / 点搜索按钮」发起(见 submit)
}
/** 恢复默认检索根(侧栏打开的目录 / 当前文件所在目录)。 */
function resetDir(): void {
customDir.value = null
}
/**
* 目录范围共用的过滤选项。
*
* - 笔记库范围**不暴露**这两个条件:库是「找笔记」的场景,按类型 / 目录过滤只会添乱。
* 类型送 `null`(不过滤),跳过目录送 `null` 让后端用它内置的默认清单兜底(避免
* 走 `.git` / `node_modules`,那是安全网而不是用户配置项);
* - 开关关掉时:类型送 `null`(不过滤),跳过目录送**空串**(明确「不跳过任何目录」)——
* 送 `null` 会退回后端默认清单,正好是关掉开关的反效果。
*/
function pathFilters(): { fileTypes: string | null; skipDirs: string | null } {
if (props.scope === 'library') return { fileTypes: null, skipDirs: null }
return {
fileTypes: useFileTypes.value ? fileTypes.value : null,
skipDirs: useSkipDirs.value ? skipDirs.value : ''
}
}
/** 记下这次检索用到的条件(只在真正发起检索时记,边打字不写历史)。 */
function rememberPathInputs(): void {
remember('pattern', pattern.value)
remember('dir', activeDir.value)
// 只有目录范围才用到这两个条件
if (props.scope !== 'dir') return
if (useFileTypes.value) remember('fileTypes', fileTypes.value)
if (useSkipDirs.value) remember('skipDirs', skipDirs.value)
}
async function runPathSearch(): Promise<void> {
const keyword = pattern.value.trim()
if (!keyword || props.scope === 'file') return
const dir = activeDir.value
if (!dir) {
searchStore.error = scopeHint.value
searchStore.results = null
return
}
await searchStore.runQuery({
dir,
pattern: pattern.value,
caseSensitive: caseSensitive.value,
wholeWord: wholeWord.value,
regex: regex.value,
// 后端已把命中总数统计完整;这里只要尽量多的预览(后端夹在 1..=5000),
// 界面由结果面板分段渲染,不会一次挂出几千行
limit: 5000,
...pathFilters()
})
// 结果现在在底部面板里展示(`SearchResultsPanel`),此处只负责把条件记进输入框历史
rememberPathInputs()
}
/** 回车 / 点搜索:按当前范围分派。 */
function submit(backwards = false): void {
// 显式提交才算「搜过一次」:当前文件范围是边打字边搜的,不能每个字符都进历史
remember('pattern', pattern.value)
if (isFile.value) stepFile(backwards ? -1 : 1)
else void runPathSearch()
}
// ===== 当前目录 / 笔记库:批量替换(会改写磁盘) =====
const replacing = ref(false)
const replaceConfirmOpen = ref(false)
/**
* 确认框文案:把「会影响什么」说清楚 —— `ConfirmDialog` 的用途就在于此
* (规范明确不用 `window.confirm`,正是因为它承载不了这句话)。
*/
const replaceConfirmText = computed(() => {
const r = results.value
const files = r?.files.length ?? 0
const total = r?.total ?? 0
const to = replaceText.value || '(空)'
let text =
`将在 ${files} 个文件中,把 ${total} 处「${pattern.value}」替换为「${to}」。` +
'此操作直接改写磁盘文件,无法在编辑器里撤销。' +
'每个文件按它自己的原编码写回;编码装不下替换内容的文件会跳过并在结果里列出。'
if (r?.truncated) {
text += `命中总数超出单次替换上限(5000 处),本次只替换前面一部分,完成后可再次执行。`
}
return text
})
function askPathReplace(): void {
if (!results.value?.total || !pattern.value.trim() || replacing.value) return
replaceConfirmOpen.value = true
}
/** 「全部替换」按钮的提示(写在这里而不是模板里,避免模板表达式的空值收窄问题)。 */
const pathReplaceTitle = computed(() => {
const r = results.value
if (!r?.total) return '先检索出结果,再替换'
return `在 ${r.totalFiles} 个文件中替换 ${r.total} 处(改写磁盘,会先确认)`
})
async function runPathReplace(): Promise<void> {
replaceConfirmOpen.value = false
const dir = activeDir.value
if (!dir) return
replacing.value = true
try {
const result = await editorClient.replaceInPath({
dir,
pattern: pattern.value,
replacement: replaceText.value,
caseSensitive: caseSensitive.value,
wholeWord: wholeWord.value,
regex: regex.value,
// 替换仍是「改写磁盘」的有界操作(后端停在文件边界),上限用满 5000
limit: 5000,
...pathFilters()
})
remember('replace', replaceText.value)
rememberPathInputs()
// 结果面板里的行号 / 预览已经全部过期 —— 按原条件重扫一次(顺带刷新记录里的命中数)
await runPathSearch()
emit('replaced', result)
} catch (e) {
searchStore.error = String(e)
} finally {
replacing.value = false
}
}
function close(): void {
emit('update:open', false)
}
function setScope(scope: SearchScope): void {
if (props.scope === scope) return
emit('update:scope', scope)
}
// ===== 联动 =====
let debounce: ReturnType<typeof setTimeout> | null = null
// 边打字边搜只对「当前文件」成立:目录 / 库是磁盘扫描,交给回车触发
watch([pattern, caseSensitive, wholeWord, regex], () => {
if (!props.open || !isFile.value) return
if (debounce) clearTimeout(debounce)
debounce = setTimeout(() => {
debounce = null
runFileSearch()
}, 120)
})
// 换范围:切到「当前文件」时立即重算高亮(内存里搜,没有成本)。
// 切到目录 / 库**不**自动搜 —— 检索一律由回车 / 点搜索按钮发起(见 submit)
watch(
() => props.scope,
scope => {
if (debounce) clearTimeout(debounce)
if (scope === 'file') runFileSearch()
}
)
// 说明:**不**在目录根变化时清空结果面板。
//
// 面板展示的是「某条检索记录的结果」,它自带完整条件(目录 / 关键词 / 过滤),是自洽的;
// 用户在卡片里改目录或改关键词,都不该把已经搜出来的结果擦掉 —— 那会让「先搜完再慢慢看」
// 这个主要用法失效。要换内容就再搜一次,结果会整体替换。
watch(
() => props.open,
open => {
if (!open) {
clearFileHighlights()
return
}
// 先看有没有选中文本要带进来,再决定关键词从哪儿来
prefillFromSelection()
void nextTick(() => patternRef.value?.focusAndSelect())
// 打开卡片:当前文件范围立即重算高亮;目录 / 库不开搜(要搜得自己按回车)
if (isFile.value) runFileSearch()
}
)
</script>
<template>
<div
v-if="open"
class="flex w-full shrink-0 flex-col border-b-2 border-primary/60 bg-popover text-popover-foreground"
@keydown.esc.prevent="close"
>
<!-- 第 1 行:关键词 + 计数 + 匹配选项 + 上一个 / 下一个 + 关闭 -->
<div class="flex h-8 items-center gap-0.5 px-2">
<Button
variant="ghost"
size="icon-sm"
:title="showReplace ? '收起替换' : '展开替换'"
@click="showReplace = !showReplace"
>
<component :is="showReplace ? ChevronDown : ChevronRight" class="size-3.5" />
</Button>
<SearchHistoryInput
ref="patternRef"
v-model="pattern"
:history="history.pattern"
:placeholder="
scope === 'file' ? '在当前文件中查找…' : scope === 'dir' ? '在目录中查找…' : '在笔记库中查找…'
"
class="w-[420px] min-w-[140px]"
input-class="h-6 text-xs"
@submit="submit(false)"
@submit-backwards="submit(true)"
@remove-history="forget('pattern', $event)"
@clear-history="clearHistory('pattern')"
/>
<!-- 计数只在当前文件范围有意义(目录 / 库的结果数在底部结果面板) -->
<span
v-if="isFile"
class="min-w-[52px] shrink-0 text-right text-[11px] tabular-nums text-muted-foreground"
>
{{ matchCount ? `${currentMatch}/${matchCount}` : '无结果' }}
</span>
<Button
variant="ghost"
size="icon-sm"
:title="caseSensitive ? '区分大小写:开' : '区分大小写:关'"
:class="caseSensitive && 'bg-active text-foreground'"
@click="caseSensitive = !caseSensitive"
>
<CaseSensitive class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
:title="wholeWord ? '全词匹配:开' : '全词匹配:关'"
:class="wholeWord && 'bg-active text-foreground'"
@click="wholeWord = !wholeWord"
>
<WholeWord class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
:title="regex ? '正则表达式:开' : '正则表达式:关'"
:class="regex && 'bg-active text-foreground'"
@click="regex = !regex"
>
<Regex class="size-3.5" />
</Button>
<template v-if="isFile">
<Button
variant="ghost"
size="icon-sm"
title="上一个 (Shift+Enter)"
:disabled="!matchCount"
@click="stepFile(-1)"
>
<ChevronUp class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="下一个 (Enter)"
:disabled="!matchCount"
@click="stepFile(1)"
>
<ChevronDown class="size-3.5" />
</Button>
</template>
<Button v-else variant="ghost" size="icon-sm" title="搜索 (Enter)" @click="submit(false)">
<Loader2 v-if="searching" class="size-3.5 animate-spin" />
<Search v-else class="size-3.5" />
</Button>
<!-- 选项 / 导航按钮紧跟输入框左移,只有关闭按钮留在最右 -->
<div class="flex-1" />
<Button variant="ghost" size="icon-sm" title="关闭 (Esc)" @click="close">
<X class="size-3.5" />
</Button>
</div>
<!-- 第 2 行:替换。当前文件走 CM6(改内存),目录 / 库走 Rust 批量替换(改写磁盘) -->
<div v-if="showReplace" class="flex h-8 items-center gap-0.5 px-2">
<!-- 空位 = 上一行那个 size-7(28px)的展开按钮,**行内间距也必须一样**(gap-0.5)
才能让两个输入框的左边缘严格重合(`gap-1` 会多推出去 2px) -->
<div class="w-7 shrink-0" />
<SearchHistoryInput
v-model="replaceText"
:history="history.replace"
placeholder="替换为…"
class="w-[420px] min-w-[140px]"
input-class="h-6 text-xs"
@submit="isFile ? replaceCurrent() : askPathReplace()"
@remove-history="forget('replace', $event)"
@clear-history="clearHistory('replace')"
/>
<template v-if="isFile">
<Button variant="outline" size="sm" :disabled="!matchCount" @click="replaceCurrent">
替换
</Button>
<Button variant="outline" size="sm" :disabled="!matchCount" @click="replaceAll">
全部替换
</Button>
</template>
<Button
v-else
variant="outline"
size="sm"
:disabled="!results?.total || replacing"
:title="pathReplaceTitle"
@click="askPathReplace"
>
<Loader2 v-if="replacing" class="size-3 animate-spin" />
<ReplaceAll v-else class="size-3" />
全部替换
</Button>
</div>
<!-- 第 3 行:范围 + 检索根 -->
<div class="flex items-center gap-1 border-t border-border px-2 py-1">
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[11px] transition-colors duration-150"
:class="
scope === 'file'
? 'bg-active text-foreground'
: 'text-fg-secondary hover:bg-hover hover:text-foreground'
"
@click="setScope('file')"
>
当前文件
</button>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[11px] transition-colors duration-150"
:class="
scope === 'dir'
? 'bg-active text-foreground'
: 'text-fg-secondary hover:bg-hover hover:text-foreground'
"
title="在目录中查找(默认为侧栏打开的目录 / 当前文件所在目录,可手动输入或选择)"
@click="setScope('dir')"
>
目录
</button>
<button
type="button"
class="rounded-sm px-1.5 py-0.5 text-[11px] transition-colors duration-150 disabled:pointer-events-none disabled:opacity-50"
:class="
scope === 'library'
? 'bg-active text-foreground'
: 'text-fg-secondary hover:bg-hover hover:text-foreground'
"
:disabled="!libraryPath"
title="在笔记库根目录中查找"
@click="setScope('library')"
>
笔记库
</button>
<!-- 检索根:目录范围可自由输入,右侧图标打开系统选择器;库范围只读展示 -->
<template v-if="scope === 'dir'">
<SearchHistoryInput
v-model="dirValue"
:history="history.dir"
placeholder="输入或选择检索目录…"
input-class="h-6 font-mono text-[11px]"
class="ml-1 min-w-0 flex-1"
@submit="runPathSearch()"
@remove-history="forget('dir', $event)"
@clear-history="clearHistory('dir')"
/>
<Button
variant="ghost"
size="icon-sm"
class="shrink-0"
title="打开系统目录选择器"
@click="pickDir"
>
<FolderOpen class="size-3.5" />
</Button>
<Button
v-if="customDir !== null"
variant="ghost"
size="icon-sm"
class="shrink-0"
title="恢复默认目录(侧栏打开的目录 / 当前文件所在目录)"
@click="resetDir"
>
<RotateCcw class="size-3.5" />
</Button>
</template>
<span v-else-if="scopeHint" class="ml-2 min-w-0 flex-1 truncate text-[10px] text-fg-disabled" :title="scopeHint">
{{ scopeHint }}
</span>
<span v-else-if="!isFile && !pattern.trim()" class="ml-2 text-[10px] text-fg-disabled">
输入关键词后按回车检索
</span>
</div>
<!-- 第 4 行:过滤条件。**只有目录范围**需要 —— 笔记库是「找笔记」,过滤只会添乱 -->
<div v-if="scope === 'dir'" class="flex items-center gap-4 border-t border-border px-2 py-1">
<div class="flex w-72 shrink-0 items-center gap-1.5">
<Button
variant="ghost"
size="icon-sm"
class="shrink-0"
:title="useFileTypes ? '按文件类型过滤:开' : '按文件类型过滤:关(搜全部文件)'"
:class="useFileTypes && 'bg-active text-foreground'"
@click="useFileTypes = !useFileTypes"
>
<FileType class="size-3.5" />
</Button>
<span class="shrink-0 text-xs text-foreground">文件类型</span>
<SearchHistoryInput
v-model="fileTypes"
:history="history.fileTypes"
:disabled="!useFileTypes"
placeholder="*.*|*.ts|*.vue"
input-class="h-6 font-mono text-[11px]"
class="min-w-0 flex-1"
@submit="runPathSearch()"
@remove-history="forget('fileTypes', $event)"
@clear-history="clearHistory('fileTypes')"
/>
</div>
<div class="flex min-w-0 flex-1 items-center gap-1.5">
<Button
variant="ghost"
size="icon-sm"
class="shrink-0"
:title="useSkipDirs ? '按清单跳过目录:开' : '不跳过任何目录(含 node_modules 等)'"
:class="useSkipDirs && 'bg-active text-foreground'"
@click="useSkipDirs = !useSkipDirs"
>
<FolderX class="size-3.5" />
</Button>
<span class="shrink-0 text-xs text-foreground">跳过目录</span>
<SearchHistoryInput
v-model="skipDirs"
:history="history.skipDirs"
:disabled="!useSkipDirs"
placeholder="node_modules|.git|dist"
input-class="h-6 font-mono text-[11px]"
class="min-w-0 flex-1"
@submit="runPathSearch()"
@remove-history="forget('skipDirs', $event)"
@clear-history="clearHistory('skipDirs')"
/>
</div>
</div>
<!-- 目录 / 库替换的确认:这是会改写磁盘的不可逆操作,必须让用户看清影响面 -->
<ConfirmDialog
v-model:open="replaceConfirmOpen"
variant="danger"
title="在目录中替换"
:description="replaceConfirmText"
confirm-text="全部替换"
:loading="replacing"
@confirm="runPathReplace"
/>
</div>
</template>
@@ -0,0 +1,45 @@
<script setup lang="ts">
/**
* 文档标签栏(P4-5)。
*
* 一个编辑器窗口内可同时打开多篇文档,每个标签**独立**保存内容、编码 / 换行、
* 视图模式与未保存状态。标签的「脏」指示点用 store 的 `tabViews`:活动标签取
* 实时值(正在敲字),后台标签取切换时收回的快照。
*/
import { FileCode2, FileText, X } from '@lucide/vue'
import { useEditorStore } from '@/stores/editorStore'
const emit = defineEmits<{ close: [id: string] }>()
const store = useEditorStore()
</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)"
>
<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)"
>
<X class="size-3" />
</button>
</div>
</div>
</template>
@@ -0,0 +1,282 @@
<script setup lang="ts">
/**
* 顶部快捷操作行(原「工具栏」)。
*
* # 为什么只有图标
*
* 文件名在**窗口标题**与**标签栏**里都有了,工具栏再显示一遍是重复信息;按钮文字
* 也会把这一行撑得很宽。因此整行统一为图标按钮,标题(含快捷键)走 tooltip。
*
* # 一行里放两类东西
*
* 1. **侧栏导航**(库 / 目录 / 最近)—— 从侧栏内部搬上来,侧栏只留内容;
* 2. **文档操作**(在路径中查找 / 打开 / 快速打开 / 保存 / 视图 / 导出)+ 笔记的
* Markdown 格式化。检索不再是「侧栏的一个视图」,而是统一搜索器(EditorSearch),
* 因此这个按钮只负责把搜索器叫出来,不参与侧栏高亮。
*
* 配色快切已移除:主题是配置项,只在模块设置页出现,避免两个入口改同一份设置。
*/
import {
Bold,
Code,
Eye,
FileDown,
FilePlus,
FileSearch,
FolderOpen,
FolderTree,
Heading1,
Heading2,
Heading3,
History,
Italic,
Library,
Link,
List,
ListChecks,
Loader2,
PanelLeft,
Quote,
Save,
Search,
SquareCode,
Strikethrough
} from '@lucide/vue'
import { ref } from 'vue'
import { open } from '@tauri-apps/plugin-dialog'
import { toast } from 'vue-sonner'
import type { Command } from '@codemirror/view'
import { Button } from '@/components/ui/button'
import { useEditorStore } from '@/stores/editorStore'
import { editorClient } from '../editorClient'
import { editorCommands } from '../editor/keymap'
import type { NoteViewMode } from '@/types/editor'
type SideView = 'library' | 'directory' | 'recent'
const props = defineProps<{
apply: (command: Command) => void
viewMode: NoteViewMode
dirty: boolean
saving: boolean
/** 侧栏是否可见(决定开关按钮的状态与 tooltip) */
sidebarVisible: boolean
}>()
const emit = defineEmits<{
'update:viewMode': [value: NoteViewMode]
save: []
'open-file': []
/** 新建临时文件(草稿) */
'new-file': []
'quick-open': []
'toggle-sidebar': []
nav: [view: SideView]
/** 打开统一搜索器(在路径中查找) */
'open-search': []
}>()
const store = useEditorStore()
const run = (command: Command) => props.apply(command)
const exporting = ref(false)
/** 侧栏导航按钮当前是否处于「选中」状态(侧栏可见且视图匹配)。 */
function isActive(view: SideView): boolean {
return props.sidebarVisible && store.sideView === view
}
/**
* 导出当前笔记为 HTML。
*
* 渲染链路(markdown-it + DOMPurify + highlight.js)**按需 import**:
* 它约 1MB,而导出是低频动作 —— 静态引入会让「打开编辑器窗口」这个最常见的动作
* 也背上这份体积。
*/
async function exportHtml(): Promise<void> {
if (!store.currentRelPath) return
exporting.value = true
try {
const doc = await editorClient.readNote(store.currentRelPath)
const { renderNoteHtml } = await import('../editor/markdownExport')
const html = renderNoteHtml({
title: store.currentName || doc.name.replace(/\.md$/i, ''),
fileName: doc.name,
markdown: doc.content,
highlight: store.settings.exportHighlight
})
const dest = await open({
title: '导出为 HTML',
defaultPath: `${doc.name.replace(/\.md$/i, '')}.html`,
filters: [{ name: 'HTML 文件', extensions: ['html'] }]
})
if (typeof dest !== 'string') return
const saved = await editorClient.exportNote(store.currentRelPath, html, dest)
toast.success(`已导出:${saved}`)
} catch (e) {
toast.error(`导出失败:${String(e)}`)
} finally {
exporting.value = false
}
}
</script>
<template>
<div
class="flex h-9 shrink-0 items-center gap-0.5 overflow-x-auto border-b border-border px-2"
>
<!-- 侧栏开关 -->
<Button
variant="ghost"
size="icon-sm"
:title="sidebarVisible ? '隐藏侧栏' : '显示侧栏'"
@click="emit('toggle-sidebar')"
>
<PanelLeft class="size-3.5" />
</Button>
<div class="mx-1 h-4 w-px shrink-0 bg-divider" />
<!-- 侧栏导航:库 / 目录 / 最近 -->
<Button
variant="ghost"
size="icon-sm"
title="笔记库"
:class="isActive('library') && 'bg-active text-foreground'"
@click="emit('nav', 'library')"
>
<Library class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="本地目录"
:class="isActive('directory') && 'bg-active text-foreground'"
@click="emit('nav', 'directory')"
>
<FolderTree class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="在路径中查找 (Ctrl+Shift+F)"
@click="emit('open-search')"
>
<Search class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="最近打开"
:class="isActive('recent') && 'bg-active text-foreground'"
@click="emit('nav', 'recent')"
>
<History class="size-3.5" />
</Button>
<div class="mx-1 h-4 w-px shrink-0 bg-divider" />
<!-- 文档操作 -->
<Button
variant="ghost"
size="icon-sm"
title="新建临时文件(草稿,存放在应用数据目录;关闭时可选择保存到别处或删除)"
@click="emit('new-file')"
>
<FilePlus class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="打开磁盘文件 (Ctrl+O)" @click="emit('open-file')">
<FolderOpen class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="快速打开 (Ctrl+P)" @click="emit('quick-open')">
<FileSearch class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
:title="dirty ? '保存 (Ctrl+S)' : '没有需要保存的改动'"
:disabled="!dirty || saving"
@click="emit('save')"
>
<Loader2 v-if="saving" class="size-3.5 animate-spin" />
<Save v-else class="size-3.5" />
</Button>
<Button
v-if="store.kind === 'note'"
variant="ghost"
size="icon-sm"
:title="viewMode === 'wysiwyg' ? '切到源码视图 (Ctrl+Shift+M)' : '切到所见即所得 (Ctrl+Shift+M)'"
@click="emit('update:viewMode', viewMode === 'wysiwyg' ? 'source' : 'wysiwyg')"
>
<Eye class="size-3.5" />
</Button>
<Button
v-if="store.kind === 'note' && store.currentRelPath"
variant="ghost"
size="icon-sm"
:disabled="exporting"
title="导出为独立 HTML(可离线打开或系统打印成 PDF)"
@click="exportHtml"
>
<Loader2 v-if="exporting" class="size-3.5 animate-spin" />
<FileDown v-else class="size-3.5" />
</Button>
<!-- Markdown 格式化(仅笔记) -->
<template v-if="store.kind === 'note'">
<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" />
</Button>
<Button variant="ghost" size="icon-sm" title="斜体 (Ctrl+I)" @click="run(editorCommands.italic)">
<Italic class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="删除线 (Ctrl+Shift+X)"
@click="run(editorCommands.strikethrough)"
>
<Strikethrough class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="行内代码 (Ctrl+E)"
@click="run(editorCommands.inlineCode)"
>
<Code class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="链接 (Ctrl+K)" @click="run(editorCommands.link)">
<Link class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="一级标题 (Ctrl+1)" @click="run(editorCommands.heading(1))">
<Heading1 class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="二级标题 (Ctrl+2)" @click="run(editorCommands.heading(2))">
<Heading2 class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="三级标题 (Ctrl+3)" @click="run(editorCommands.heading(3))">
<Heading3 class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="无序列表" @click="run(editorCommands.bulletList)">
<List class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="任务列表" @click="run(editorCommands.taskList)">
<ListChecks class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="引用" @click="run(editorCommands.quote)">
<Quote class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="代码块 (Ctrl+Shift+C)"
@click="run(editorCommands.codeBlock)"
>
<SquareCode class="size-3.5" />
</Button>
</template>
</div>
</template>
@@ -37,10 +37,10 @@ import {
SelectValue
} from '@/components/ui/select'
import { SettingRow } from '@/components/common'
import { useNotesStore } from '@/stores/notesStore'
import { notesClient } from '../notesClient'
import { useEditorStore } from '@/stores/editorStore'
import { editorClient } from '../editorClient'
const store = useNotesStore()
const store = useEditorStore()
const busy = ref<'import' | 'export' | 'zip' | null>(null)
@@ -101,7 +101,7 @@ async function doImport(kind: 'file' | 'dir'): Promise<void> {
)
if (typeof selected !== 'string') return
busy.value = 'import'
const report = await notesClient.import(selected, '')
const report = await editorClient.import(selected, '')
await store.refreshLibrary()
await store.syncIndex()
const renamed = report.renamed ? `,${report.renamed} 篇重名已加序号` : ''
@@ -126,7 +126,7 @@ async function doExportHtml(): Promise<void> {
return
}
try {
const doc = await notesClient.readNote(relPath)
const doc = await editorClient.readNote(relPath)
// **动态引入**:`markdownExport` 会拉进 markdown-it + DOMPurify + highlight.js
// (实测约 1MB),而导出是低频动作。静态引入会让「笔记」模块页一打开就下载
// 这三个包(chunk 从 ~130kB 涨到 1.1MB),把首屏拖垮。
@@ -146,7 +146,7 @@ async function doExportHtml(): Promise<void> {
})
if (typeof dest !== 'string') return
busy.value = 'export'
const saved = await notesClient.exportNote(relPath, html, dest)
const saved = await editorClient.exportNote(relPath, html, dest)
toast.success(`已导出:${saved}`, {
action: { label: '打开', onClick: () => void openPath(saved) }
})
@@ -170,7 +170,7 @@ async function doExportZip(): Promise<void> {
})
if (typeof dest !== 'string') return
busy.value = 'zip'
const saved = await notesClient.exportZip(dest, scope || undefined)
const saved = await editorClient.exportZip(dest, scope || undefined)
toast.success(`已导出:${saved}`, {
action: { label: '打开目录', onClick: () => void openPath(saved.replace(/[\\/][^\\/]+$/, '')) }
})
@@ -270,7 +270,7 @@ async function exportTemplates(): Promise<void> {
</div>
</SettingRow>
<SettingRow label="导出 zip" description="整库或某个目录(含 assets/,不含 .notes/)" control-width="wide">
<SettingRow label="导出 zip" description="整库或某个目录(含 assets/,不含 .editor/)" control-width="wide">
<div class="flex w-full flex-col gap-2">
<Select v-model="zipScope">
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
@@ -1,20 +1,30 @@
<script setup lang="ts">
/**
* 笔记库侧栏:目录树 / 全文检索 / 大纲 三视图 + 新建/重命名/删除 + 最近打开。
* 编辑器侧栏:**库 / 目录 / 最近** 三段。
*
* 版式对齐终端「文件管理器」的 `FilePane`(同类场景:独立窗口里的分栏列表):
* - 局部滚动一律用 `ScrollArea`(不写原生 `overflow-y-auto`,见 UI_DESIGN_SYSTEM §3.2)
* - 选中态 `bg-row-selected` / hover 态 `hover:bg-row-hover`(两态不混用同一色)
* - 紧凑输入 `h-7 text-xs`(与 FilePane 的筛选框一致)
* - 空态用 `StateBlock`,不手写占位文案
* 「检索」已不再是侧栏的一个视图 —— 它并入了统一搜索器(`EditorSearch.vue`),
* 那一处同时覆盖「当前文件 / 当前目录 / 笔记库」,侧栏只保留「去哪找文件」的导航。
*
* 树用「展开集合 + 扁平化」渲染,而不是递归子组件 —— 扁平列表能把过滤
* (只保留命中项及其祖先)一并做掉。
* # 两个并列的「根」
*
* # 三视图为什么在同一个侧栏里切换
* - **笔记库**:沙箱 + 索引 + front-matter + 双链(相对库根路径)
* - **本地目录**:任意路径 + 不进索引 + 无 front-matter 语义(真实文件系统)
*
* 目录树 / 检索 / 大纲三者是**同一时刻只需一个**的导航手段,各自单开一个面板会
* 把编辑器挤窄。用分段导航切换既省宽度,也让「我在找什么」始终只有一个答案。
* 两者是并列的导航能力,编辑对象(文件本身)才是模块中心。
*
* # 大纲 / 双链去哪了
*
* 它们描述的是**当前文档**而不是「去哪找文件」,因此移到编辑区右侧抽屉
* (见 `DrawerPanel.vue`)。侧栏只回答「去哪找」。
*
* 版式沿用终端「文件管理器」(`ScrollArea` 滚动、`bg-row-selected` 选中、
* 紧凑输入 `h-7 text-xs`、空态用 `StateBlock`)。
*
* # 字号比主界面「小一号」
*
* 侧栏是窄栏(256px)且常年挂在那里,行名与标题若用正文尺寸会显得拥挤、抢视线。
* 因此列表行统一 `text-xs`(12px)、标题与提示再用 `text-[11px]` / `text-[10px]` 递减 ——
* 层级拉开,密度也更接近 JetBrains 的工具窗口。
*/
import { computed, ref, watch } from 'vue'
import {
@@ -24,12 +34,9 @@ import {
FileText,
Folder,
FolderPlus,
Link2,
ListTree,
Loader2,
Pencil,
RotateCw,
Search,
Trash2,
X
} from '@lucide/vue'
@@ -38,58 +45,39 @@ import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { ScrollArea } from '@/components/ui/scroll-area'
import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from '@/components/ui/dialog'
import { ConfirmDialog, SegmentedNav, StateBlock } from '@/components/common'
import { useNotesStore } from '@/stores/notesStore'
import type { LibraryEntry, LibraryTreeNode } from '@/types/notes'
import SearchPanel from './SearchPanel.vue'
import MarkdownOutline from './MarkdownOutline.vue'
import BacklinksPanel from './BacklinksPanel.vue'
import { ConfirmDialog, StateBlock } from '@/components/common'
import { useEditorStore } from '@/stores/editorStore'
import type { LibraryEntry, LibraryTreeNode } from '@/types/editor'
import DirectoryPanel from './DirectoryPanel.vue'
import RecentPanel from './RecentPanel.vue'
import NewNoteDialog from './NewNoteDialog.vue'
const emit = defineEmits<{ open: [relPath: string]; jump: [from: number] }>()
const emit = defineEmits<{ open: [relPath: string] }>()
const store = useNotesStore()
const store = useEditorStore()
/** 侧栏视图 */
const view = ref<'files' | 'search' | 'outline' | 'links'>('files')
/** 已展开的目录 */
const expanded = ref<Set<string>>(new Set())
/** 名称过滤 */
const filter = ref('')
/** 当前选中的目录(新建目标;空串 = 库根) */
const selectedDir = ref('')
/** 编辑器光标行(大纲高亮用;由 NotesWindow 传入) */
const cursorLine = ref(0)
/** 侧栏视图由顶部操作行控制(`store.sideView`),这里只管内容 */
const view = computed(() => store.sideView)
defineExpose({
/** 由 NotesWindow 在光标移动时调用 */
setCursorLine: (line: number) => {
cursorLine.value = line
},
/** 由 NotesWindow 在快捷键触发时调用 */
showSearch: () => {
view.value = 'search'
},
showOutline: () => {
view.value = 'outline'
},
showFiles: () => {
view.value = 'files'
},
/** 由 NotesWindow 在 Ctrl+Shift+N 时调用 */
/** 由 EditorWindow 在顶部导航触发时调用 */
showLibrary: () => store.setSideView('library'),
/** 由 EditorWindow 在 `?folder=` 打开时调用 */
showDirectory: () => store.setSideView('directory'),
/** 由 EditorWindow 在 Ctrl+Shift+N 时调用 */
showNewNote: () => {
view.value = 'files'
store.setSideView('library')
void startNewNote()
}
})
const NAV_ITEMS = [
{ value: 'files', label: '文件', icon: FileText },
{ value: 'search', label: '检索', icon: Search },
{ value: 'outline', label: '大纲', icon: ListTree },
{ value: 'links', label: '双链', icon: Link2 }
]
// ===== 扁平化 + 过滤 =====
const flatNodes = computed(() => {
const keyword = filter.value.trim().toLowerCase()
@@ -186,24 +174,13 @@ function revealNote(relPath: string): void {
next.add(prefix)
}
expanded.value = next
view.value = 'files'
store.setSideView('library')
}
function onCreated(relPath: string): void {
revealNote(relPath)
}
/**
* 反链面板里点了「未解析链接」→ 已按名字新建了一篇。
*
* 新建动作由面板内部完成(它知道 link 的原始名字),这里只负责把树展开到新笔记、
* 并把它打开 —— 面板不持有「打开哪一篇」的知识,`store.currentRelPath` 由
* `createNote` 自己更新。
*/
function onLinkCreated(): void {
if (store.currentRelPath) revealNote(store.currentRelPath)
}
// ===== 名称输入对话框(新建文件夹 / 重命名) =====
type PromptMode = 'folder' | 'rename'
const promptOpen = ref(false)
@@ -270,13 +247,66 @@ async function rebuildIndex(): Promise<void> {
await store.refreshLibrary()
toast.success('索引已重建')
}
// ===== 宽度拖拽 =====
//
// 与底部结果面板(SearchResultsPanel)同一套 Pointer Events + setPointerCapture 范式:
// 指针被捕获后拖出窗口边界也不丢事件。宽度落 localStorage,下次打开保持。
const WIDTH_KEY = 'thing_editor_sidebar_width'
const MIN_WIDTH = 200
const MAX_WIDTH = 520
function loadWidth(): number {
try {
const raw = localStorage.getItem(WIDTH_KEY)
const n = raw ? Number(raw) : NaN
return Number.isFinite(n) ? Math.min(MAX_WIDTH, Math.max(MIN_WIDTH, n)) : 256
} catch {
return 256
}
}
const width = ref(loadWidth())
const resizing = ref(false)
let dragStartX = 0
let dragStartWidth = 0
function onResizeStart(event: PointerEvent): void {
dragStartX = event.clientX
dragStartWidth = width.value
resizing.value = true
;(event.currentTarget as HTMLElement).setPointerCapture(event.pointerId)
}
function onResizeMove(event: PointerEvent): void {
if (!resizing.value) return
// 往右拖 = 侧栏变宽
width.value = Math.round(Math.min(MAX_WIDTH, Math.max(MIN_WIDTH, dragStartWidth + (event.clientX - dragStartX))))
}
function onResizeEnd(event: PointerEvent): void {
if (!resizing.value) return
resizing.value = false
;(event.currentTarget as HTMLElement).releasePointerCapture(event.pointerId)
try {
localStorage.setItem(WIDTH_KEY, String(width.value))
} catch {
/* 忽略存储失败 */
}
}
</script>
<template>
<aside class="flex h-full min-h-0 w-64 shrink-0 flex-col border-r border-border">
<!-- 头部操作 -->
<div class="flex h-11 shrink-0 items-center gap-1 border-b border-border px-2">
<span class="ml-1 text-[13px] font-medium text-foreground">笔记库</span>
<aside
class="relative flex h-full min-h-0 shrink-0 flex-col border-r border-border"
:style="{ width: `${width}px` }"
>
<!-- 头部:仅库视图需要库操作(导航已在顶部操作行) -->
<div
v-if="view === 'library'"
class="flex h-9 shrink-0 items-center gap-1 border-b border-border px-2"
>
<span class="ml-1 text-xs font-medium text-foreground">笔记库</span>
<div class="ml-auto flex items-center gap-0.5">
<Button
variant="ghost"
@@ -301,16 +331,11 @@ async function rebuildIndex(): Promise<void> {
</div>
</div>
<!-- 视图切换 -->
<div class="shrink-0 px-2 pt-2">
<SegmentedNav v-model="view" :items="NAV_ITEMS" block />
</div>
<!-- ===== 文件视图 ===== -->
<template v-if="view === 'files'">
<!-- ===== 库视图 ===== -->
<template v-if="view === 'library'">
<div class="shrink-0 px-2 py-2">
<div class="relative">
<Input v-model="filter" placeholder="按名称过滤…" class="h-7 pr-6 text-xs" />
<Input v-model="filter" placeholder="按名称过滤…" class="h-7 pr-6 text-[11px]" />
<button
v-if="filter"
type="button"
@@ -320,7 +345,7 @@ async function rebuildIndex(): Promise<void> {
<X class="size-3" />
</button>
</div>
<p class="mt-1.5 px-0.5 text-[11px] text-muted-foreground">
<p class="mt-1.5 px-0.5 text-[10px] text-muted-foreground">
新建目标:<span class="text-fg-secondary">{{ targetLabel }}</span>
</p>
</div>
@@ -329,7 +354,7 @@ async function rebuildIndex(): Promise<void> {
<div class="px-1.5 pb-2">
<div v-if="store.loading" class="flex items-center justify-center gap-2 p-4">
<Loader2 class="size-3.5 animate-spin text-muted-foreground" />
<span class="text-xs text-muted-foreground">正在扫描库…</span>
<span class="text-[11px] text-muted-foreground">正在扫描库…</span>
</div>
<StateBlock
@@ -364,7 +389,7 @@ async function rebuildIndex(): Promise<void> {
class="size-3.5 shrink-0 opacity-70"
/>
<Folder v-if="item.entry.isDir" class="size-3.5 shrink-0 opacity-80" />
<span class="truncate">{{ item.entry.name }}</span>
<span class="truncate text-xs">{{ item.entry.name }}</span>
<div class="ml-auto flex shrink-0 items-center gap-0.5 opacity-0 group-hover:opacity-100">
<button
@@ -388,44 +413,26 @@ async function rebuildIndex(): Promise<void> {
</template>
</div>
</ScrollArea>
<!-- 最近打开 -->
<div v-if="store.recent.length" class="shrink-0 border-t border-border px-2 py-2">
<p class="px-0.5 pb-1 text-[11px] font-medium text-muted-foreground">最近打开</p>
<ScrollArea class="max-h-32">
<div class="px-0.5">
<button
v-for="item in store.recent"
:key="item.relPath"
type="button"
class="flex h-6 w-full items-center truncate rounded-sm px-1 text-left text-xs text-fg-secondary hover:bg-row-hover hover:text-foreground"
@click="emit('open', item.relPath)"
>
{{ item.name.replace(/\.md$/i, '') }}
</button>
</div>
</ScrollArea>
</div>
</template>
<!-- ===== 检索视图 ===== -->
<SearchPanel v-else-if="view === 'search'" class="min-h-0 flex-1" @open="emit('open', $event)" />
<!-- ===== 目录视图(本地文件系统) ===== -->
<DirectoryPanel v-else-if="view === 'directory'" class="min-h-0 flex-1" />
<!-- ===== 大纲视图 ===== -->
<MarkdownOutline
v-else-if="view === 'outline'"
class="min-h-0 flex-1"
:cursor-line="cursorLine"
@jump="emit('jump', $event)"
/>
<!-- ===== 最近视图 ===== -->
<RecentPanel v-else class="min-h-0 flex-1" />
<!-- ===== 双链视图 ===== -->
<BacklinksPanel
v-else
class="min-h-0 flex-1"
:rel-path="store.currentRelPath"
@open="emit('open', $event)"
@create="onLinkCreated"
<!--
右边缘拖拽手柄:4px 宽、贴住整条右边框(比边框线好点中),hover / 拖动时高亮。
拖动实时改宽,松手落盘 —— 与底部结果面板的高度拖拽同一套交互。
-->
<div
class="absolute inset-y-0 right-0 z-10 w-1 cursor-col-resize touch-none select-none transition-colors duration-150 hover:bg-primary/30"
:class="resizing && 'bg-primary/40'"
title="拖动调整侧栏宽度"
@pointerdown="onResizeStart"
@pointermove="onResizeMove"
@pointerup="onResizeEnd"
@pointercancel="onResizeEnd"
/>
</aside>
@@ -463,4 +470,4 @@ async function rebuildIndex(): Promise<void> {
<!-- 新建笔记(名称 + 模板) -->
<NewNoteDialog v-model:open="newNoteOpen" :dir-rel="selectedDir" @created="onCreated" />
</template>
</template>
+215
View File
@@ -0,0 +1,215 @@
<script setup lang="ts">
/**
* 双链图谱(P5-4):把 `editor_link_graph` 的内部链接边画成力导向图。
*
* 布局是**一次性计算**(不跑动画):简化 Fruchterman-Reingold 迭代若干轮后
* 归一化到 viewBox,再用静态 SVG 渲染。理由是图谱打开频率低、节点规模小,
* 省掉 requestAnimationFrame 循环能让组件保持「无副作用」、易于推理。
*
* 点击节点 → 打开对应笔记。当前笔记节点高亮。
*/
import { computed, onMounted } from 'vue'
import { Loader2, Share2 } from '@lucide/vue'
import { ScrollArea } from '@/components/ui/scroll-area'
import { StateBlock } from '@/components/common'
import { useEditorStore } from '@/stores/editorStore'
const emit = defineEmits<{ open: [relPath: string] }>()
const store = useEditorStore()
/** 节点上限:超过则只画前 N 个(避免 O(n²) 迭代在大库上卡住主线程) */
const NODE_LIMIT = 400
const WIDTH = 520
const HEIGHT = 520
const PADDING = 24
const ITERATIONS = 180
interface GNode {
id: string
label: string
x: number
y: number
deg: number
}
interface GEdge {
a: number
b: number
}
const layout = computed(() => {
const index = new Map<string, number>()
const nodes: GNode[] = []
const addNode = (id: string): number => {
const found = index.get(id)
if (found !== undefined) return found
if (nodes.length >= NODE_LIMIT) return -1
const label = (id.split('/').pop() ?? id).replace(/\.md$/i, '')
index.set(id, nodes.length)
nodes.push({ id, label, x: 0, y: 0, deg: 0 })
return nodes.length - 1
}
const edges: GEdge[] = []
for (const e of store.linkGraph) {
const a = addNode(e.from)
const b = addNode(e.to)
if (a < 0 || b < 0) continue
edges.push({ a, b })
nodes[a]!.deg += 1
nodes[b]!.deg += 1
}
if (!nodes.length) return { nodes: [], edges: [], truncated: false }
const n = nodes.length
// 初始环形布局
for (let i = 0; i < n; i++) {
const angle = (i / n) * Math.PI * 2
nodes[i]!.x = Math.cos(angle) * 200
nodes[i]!.y = Math.sin(angle) * 200
}
// 简化 FR:斥力 O(n²) + 沿边引力
const k = Math.sqrt((400 * 400) / Math.max(n, 1))
const temp0 = 80
for (let it = 0; it < ITERATIONS; it++) {
const temp = temp0 * (1 - it / ITERATIONS)
const dx = new Float64Array(n)
const dy = new Float64Array(n)
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
let vx = nodes[i]!.x - nodes[j]!.x
let vy = nodes[i]!.y - nodes[j]!.y
let d2 = vx * vx + vy * vy
if (d2 < 0.01) {
vx = 0.1 * (i - j) || 0.1
vy = 0.1
d2 = vx * vx + vy * vy
}
const d = Math.sqrt(d2)
const f = (k * k) / d
dx[i] += (vx / d) * f
dy[i] += (vy / d) * f
dx[j] -= (vx / d) * f
dy[j] -= (vy / d) * f
}
}
for (const e of edges) {
const vx = nodes[e.a]!.x - nodes[e.b]!.x
const vy = nodes[e.a]!.y - nodes[e.b]!.y
const d = Math.max(Math.sqrt(vx * vx + vy * vy), 0.01)
const f = (d * d) / k
dx[e.a] -= (vx / d) * f
dy[e.a] -= (vy / d) * f
dx[e.b] += (vx / d) * f
dy[e.b] += (vy / d) * f
}
for (let i = 0; i < n; i++) {
const len = Math.max(Math.sqrt(dx[i]! * dx[i]! + dy[i]! * dy[i]!), 0.001)
const step = Math.min(len, temp) / len
nodes[i]!.x += dx[i]! * step
nodes[i]!.y += dy[i]! * step
}
}
// 归一化到 viewBox(等比缩放 + 居中)
let minX = Infinity
let minY = Infinity
let maxX = -Infinity
let maxY = -Infinity
for (const nd of nodes) {
minX = Math.min(minX, nd.x)
minY = Math.min(minY, nd.y)
maxX = Math.max(maxX, nd.x)
maxY = Math.max(maxY, nd.y)
}
const scale = Math.min(
(WIDTH - PADDING * 2) / Math.max(maxX - minX, 1),
(HEIGHT - PADDING * 2) / Math.max(maxY - minY, 1)
)
const ox = (WIDTH - (maxX - minX) * scale) / 2 - minX * scale
const oy = (HEIGHT - (maxY - minY) * scale) / 2 - minY * scale
return {
nodes: nodes.map(nd => ({ ...nd, x: nd.x * scale + ox, y: nd.y * scale + oy })),
edges,
truncated: store.linkGraph.length > 0 && nodes.length >= NODE_LIMIT
}
})
const radius = (deg: number): number => Math.min(3 + deg * 1.2, 9)
const showLabels = computed(() => layout.value.nodes.length <= 60)
const isCurrent = (id: string): boolean => store.currentRelPath === id
onMounted(() => {
void store.loadLinkGraph()
})
</script>
<template>
<div class="flex h-full min-h-0 flex-col">
<div class="flex h-6 shrink-0 items-center gap-1.5 border-b border-border px-2 text-[11px] text-muted-foreground">
<Share2 class="size-3" />
<span>双链图谱</span>
<span class="ml-auto tabular-nums">{{ layout.nodes.length }} 节点 · {{ layout.edges.length }} 边</span>
</div>
<div v-if="store.loadingGraph && !layout.nodes.length" class="flex items-center justify-center gap-2 p-4">
<Loader2 class="size-3.5 animate-spin text-muted-foreground" />
<span class="text-xs text-muted-foreground">正在构建图谱…</span>
</div>
<StateBlock
v-else-if="!layout.nodes.length"
variant="empty"
title="还没有双链"
description="在笔记里写 [[另一篇]] 建立链接,图谱会显示它们的关系"
:min-height="140"
/>
<ScrollArea v-else class="min-h-0 flex-1">
<div class="px-1.5 py-2">
<svg :viewBox="`0 0 ${WIDTH} ${HEIGHT}`" class="w-full select-none">
<line
v-for="(edge, i) in layout.edges"
:key="`e${i}`"
:x1="layout.nodes[edge.a]?.x"
:y1="layout.nodes[edge.a]?.y"
:x2="layout.nodes[edge.b]?.x"
:y2="layout.nodes[edge.b]?.y"
class="stroke-border"
stroke-width="1"
/>
<g
v-for="node in layout.nodes"
:key="node.id"
class="cursor-pointer"
@click="emit('open', node.id)"
>
<title>{{ node.id }}</title>
<circle
:cx="node.x"
:cy="node.y"
:r="radius(node.deg)"
:class="isCurrent(node.id) ? 'fill-primary' : 'fill-muted-foreground'"
/>
<text
v-if="showLabels"
:x="node.x"
:y="node.y - radius(node.deg) - 2"
text-anchor="middle"
class="fill-foreground"
font-size="9"
>
{{ node.label }}
</text>
</g>
</svg>
<p v-if="layout.truncated" class="px-1 pt-1 text-[11px] text-muted-foreground">
节点较多,仅显示前 {{ NODE_LIMIT }} 个。
</p>
</div>
</ScrollArea>
</div>
</template>
@@ -7,7 +7,7 @@
*
* # 当前标题怎么算
*
* 用编辑器的光标行号(由 `NotesWindow` 通过 props 传入)与标题行号比较,取
* 用编辑器的光标行号(由 `EditorWindow` 通过 props 传入)与标题行号比较,取
* 「最后一个行号 ≤ 光标行」的标题。**不用滚动位置**:Live Preview 下装饰会让
* 每行高度不一致,按像素反推当前标题很容易差一行,而光标位置是精确的。
*/
@@ -15,7 +15,7 @@ import { computed } from 'vue'
import { Hash, ListTree } from '@lucide/vue'
import { ScrollArea } from '@/components/ui/scroll-area'
import { StateBlock } from '@/components/common'
import { useNotesStore } from '@/stores/notesStore'
import { useEditorStore } from '@/stores/editorStore'
const props = defineProps<{
/** 编辑器当前光标所在行(1 起;0 = 未知) */
@@ -24,7 +24,7 @@ const props = defineProps<{
const emit = defineEmits<{ jump: [from: number] }>()
const store = useNotesStore()
const store = useEditorStore()
/** 最浅一级标题的层级(让缩进从 0 开始,而不是每篇都从 h2 缩进一档) */
const minLevel = computed(() =>
@@ -32,7 +32,7 @@ import {
SelectTrigger,
SelectValue
} from '@/components/ui/select'
import { useNotesStore } from '@/stores/notesStore'
import { useEditorStore } from '@/stores/editorStore'
const props = defineProps<{
open: boolean
@@ -45,7 +45,7 @@ const emit = defineEmits<{
created: [relPath: string]
}>()
const store = useNotesStore()
const store = useEditorStore()
const name = ref('')
const templateId = ref('')
const busy = ref(false)
@@ -4,7 +4,7 @@
*
* # 为什么在本地过滤而不是每次都查后端
*
* 库内笔记清单在打开面板时一次性取回(上限 1000 条,`notes_list_notes`),
* 库内笔记清单在打开面板时一次性取回(上限 1000 条,`editor_list_notes`),
* 之后的每一次按键都只是对这份内存清单做子串匹配。这样输入零延迟 —— 而「按关键词
* 找文件」本来就是模糊匹配,走 FTS5 反而会因为分词器把文件名切碎而给出意外结果
* (FTS 是给正文用的)。
@@ -20,8 +20,8 @@ import { CornerDownLeft, FileText, Search } from '@lucide/vue'
import { Input } from '@/components/ui/input'
import { ScrollArea } from '@/components/ui/scroll-area'
import { StateBlock } from '@/components/common'
import { useNotesStore } from '@/stores/notesStore'
import type { NoteSearchHit } from '@/types/notes'
import { useEditorStore } from '@/stores/editorStore'
import type { NoteSearchHit } from '@/types/editor'
const props = defineProps<{ open: boolean }>()
const emit = defineEmits<{
@@ -29,7 +29,7 @@ const emit = defineEmits<{
select: [relPath: string]
}>()
const store = useNotesStore()
const store = useEditorStore()
const keyword = ref('')
const active = ref(0)
const panelRef = ref<HTMLDivElement | null>(null)
@@ -0,0 +1,136 @@
<script setup lang="ts">
/**
* 最近记录面板(P3-6):最近文件 + 最近文件夹两份列表。
*
* 「文件」与「文件夹」**分开存**(`settings.json` 的 `recentFiles` / `recentFolders`):
* 两者用途不同(打开文档 vs 打开目录),混在一起会让「最近文件夹」被文件挤掉。
* 记录与笔记库解耦 —— 库可以换 / 删,历史不该跟着丢。
*
* 失效项(路径已不存在)灰显但仍可点击清理由此产生的困惑:点击会给出明确失败提示,
* 而不是静默什么都不做。
*/
import { computed } from 'vue'
import { ExternalLink, FileText, Folder, History } from '@lucide/vue'
import { toast } from 'vue-sonner'
import { ScrollArea } from '@/components/ui/scroll-area'
import { StateBlock } from '@/components/common'
import { useEditorStore } from '@/stores/editorStore'
import type { RecentEntry } from '@/types/editor'
const store = useEditorStore()
const files = computed(() => store.recentFiles)
const folders = computed(() => store.recentFolders)
async function openFile(entry: RecentEntry): Promise<void> {
try {
await store.openDoc(entry.path)
} catch (e) {
toast.error(`打开失败:${String(e)}`)
}
}
/**
* 打开一个「最近文件夹」:读目录 + **切到侧栏的「目录」视图**。
*
* 只 `openFolder` 是不够的 —— 它只把 `dirListing` 读进 store,而侧栏还停在「最近」页,
* 于是用户点了一下什么都「没发生」(同一个列表还在那儿)。切视图才是点击应有的反馈:
* 跳到本地文件夹侧栏,直接看到这棵目录树。
*
* 先 await 再切:目录列举是异步的,提前切会先渲染一帧空态。
*/
async function openFolder(entry: RecentEntry): Promise<void> {
try {
await store.openFolder(entry.path)
store.setSideView('directory')
} catch (e) {
toast.error(`打开文件夹失败:${String(e)}`)
}
}
</script>
<template>
<div class="flex h-full min-h-0 flex-col">
<StateBlock
v-if="!files.length && !folders.length"
variant="empty"
title="还没有最近记录"
description="打开过的文件与文件夹会出现在这里"
:min-height="160"
/>
<ScrollArea v-else class="min-h-0 flex-1">
<div class="px-1.5 py-2">
<!-- 最近文件 -->
<div v-if="files.length" class="mb-2">
<div class="flex h-6 items-center gap-1.5 px-1.5 text-[11px] font-medium text-muted-foreground">
<FileText class="size-3" />
<span>最近文件</span>
<button
type="button"
class="ml-auto text-muted-foreground hover:text-foreground"
@click="store.clearRecentFiles()"
>
清空
</button>
</div>
<div
v-for="entry in files"
:key="entry.path"
class="group flex h-7 w-full cursor-pointer items-center gap-1.5 rounded-sm px-1.5 text-left text-xs transition-colors duration-150 hover:bg-row-hover"
:class="entry.exists ? 'text-fg-secondary hover:text-foreground' : 'text-fg-disabled'"
:title="entry.path"
@click="openFile(entry)"
>
<FileText class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ entry.name }}</span>
<span v-if="!entry.exists" class="shrink-0 text-[10px]">(已失效)</span>
<button
type="button"
class="ml-auto rounded-sm p-0.5 opacity-0 group-hover:opacity-100 hover:bg-active"
title="在资源管理器中显示"
@click.stop="store.revealPath(entry.path)"
>
<ExternalLink class="size-3.5" />
</button>
</div>
</div>
<!-- 最近文件夹 -->
<div v-if="folders.length">
<div class="flex h-6 items-center gap-1.5 px-1.5 text-[11px] font-medium text-muted-foreground">
<Folder class="size-3" />
<span>最近文件夹</span>
<button
type="button"
class="ml-auto text-muted-foreground hover:text-foreground"
@click="store.clearRecentFolders()"
>
清空
</button>
</div>
<div
v-for="entry in folders"
:key="entry.path"
class="group flex h-7 w-full cursor-pointer items-center gap-1.5 rounded-sm px-1.5 text-left text-xs transition-colors duration-150 hover:bg-row-hover"
:class="entry.exists ? 'text-fg-secondary hover:text-foreground' : 'text-fg-disabled'"
:title="entry.path"
@click="openFolder(entry)"
>
<History class="size-3.5 shrink-0 opacity-70" />
<span class="truncate">{{ entry.name }}</span>
<span v-if="!entry.exists" class="shrink-0 text-[10px]">(已失效)</span>
<button
type="button"
class="ml-auto rounded-sm p-0.5 opacity-0 group-hover:opacity-100 hover:bg-active"
title="在资源管理器中显示"
@click.stop="store.revealPath(entry.path)"
>
<ExternalLink class="size-3.5" />
</button>
</div>
</div>
</div>
</ScrollArea>
</div>
</template>
@@ -0,0 +1,160 @@
<script setup lang="ts">
/**
* 带「历史下拉」的输入框(查找词 / 替换串 / 目录 / 过滤条件共用)。
*
* # 为什么不用 `ui/combobox`
*
* reka-ui 的 Combobox 是「可筛选下拉」,要接 `open` / `searchTerm` / `selected` 一整套
* 受控状态;而这里要的只是「点一下图标列出用过的值,点一条填回去」。手写这一层更直白,
* 也不会和输入框自身的 Enter(提交)语义打架。
*
* # 为什么改为「图标点击展开」而不是「聚焦即展开」
*
* 聚焦即展开的问题:Tab / 点击进入输入框(哪怕只想改一两个字符)都会弹一层历史,
* 视觉噪声大。改为输入框**右侧的历史图标**点击展开 / 再点收起 —— 历史是低频动作,
* 交给显式动作更安静。失焦即收起。
*
* # 三个交互细节
*
* - 图标用 `@mousedown.prevent`:阻止默认行为后输入框不会先失焦,点击才不会被
* 先触发的 blur 吞掉;
* - 列表项同样 `@mousedown.prevent`:点选时输入框不失焦,值直接填入;
* - **Enter 只负责提交**,不做「选中第一条」—— 搜索框里回车即搜索是既有习惯,
* 让下拉抢走这个键会很难受。
*/
import { computed, ref } from 'vue'
import { History, X } from '@lucide/vue'
import { Input } from '@/components/ui/input'
import { ScrollArea } from '@/components/ui/scroll-area'
const props = defineProps<{
modelValue: string
placeholder?: string
/** 历史条目(新的在前) */
history: string[]
disabled?: boolean
/** 透传给 `Input` 的 class(行高 / 内边距等由调用方决定) */
inputClass?: string
}>()
const emit = defineEmits<{
'update:modelValue': [value: string]
/** 回车:提交(父组件决定是「搜索」还是「替换」) */
submit: []
/** Shift+回车:反向提交(只有「查找」用得上,即「上一个」) */
submitBackwards: []
removeHistory: [value: string]
clearHistory: []
}>()
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 open = computed(() => manualOpen.value && !props.disabled && items.value.length > 0)
function toggleHistory(): void {
manualOpen.value = !open.value
}
function closeHistory(): void {
manualOpen.value = false
}
/** 聚焦并全选已有内容(打开卡片时用:直接输入即可覆盖)。 */
function focusAndSelect(): void {
inputRef.value?.focus()
inputRef.value?.element()?.select()
}
defineExpose({ focusAndSelect })
</script>
<template>
<!-- 宽度由调用方给:搜索 / 替换固定窄宽,目录与过滤条件撑满剩余空间 -->
<div class="relative min-w-0">
<Input
ref="inputRef"
:model-value="modelValue"
:placeholder="placeholder"
:disabled="disabled"
:class="[inputClass, 'pr-7']"
@update:model-value="emit('update:modelValue', String($event))"
@focus="manualOpen = false"
@blur="closeHistory"
@keydown.enter.exact.prevent="emit('submit')"
@keydown.shift.enter.exact.prevent="emit('submitBackwards')"
/>
<!-- 历史开关图标:显式动作展开 / 收起(聚焦不再自动弹层) -->
<button
type="button"
class="absolute top-1/2 right-1 -translate-y-1/2 rounded-sm p-0.5 transition-colors duration-150"
:class="open ? 'text-foreground' : 'text-muted-foreground hover:text-foreground'"
:title="open ? '收起历史' : '展开历史'"
:disabled="disabled"
tabindex="-1"
@mousedown.prevent
@click="toggleHistory"
>
<History class="size-3" />
</button>
<!-- 历史下拉:绝对定位贴在输入框下方,宽度跟随输入框;列表用 ScrollArea 滚动 -->
<div
v-if="open"
class="absolute top-full left-0 z-40 mt-1 w-full rounded-md border border-border bg-popover p-0.5 shadow-md"
>
<div class="flex items-center gap-1 px-1.5 py-1 text-[10px] text-fg-disabled">
<History class="size-3" />历史
<button
type="button"
class="ml-auto rounded-sm px-1 transition-colors duration-150 hover:bg-hover hover:text-foreground"
title="清空这组历史"
@mousedown.prevent="emit('clearHistory')"
>
清空
</button>
</div>
<ScrollArea class="max-h-56">
<div class="pb-0.5">
<div
v-for="item in items"
:key="item"
class="group flex items-center gap-1 rounded-sm hover:bg-row-hover"
>
<button
type="button"
class="min-w-0 flex-1 truncate px-1.5 py-1 text-left font-mono text-[11px] text-fg-secondary transition-colors duration-150 group-hover:text-foreground"
:title="item"
@mousedown.prevent="emit('update:modelValue', item)"
>
{{ item }}
</button>
<button
type="button"
class="mr-1 shrink-0 rounded-sm p-0.5 opacity-0 transition-opacity group-hover:opacity-100 hover:bg-active"
title="从历史中删除"
@mousedown.prevent="emit('removeHistory', item)"
>
<X class="size-3" />
</button>
</div>
</div>
</ScrollArea>
</div>
</div>
</template>
@@ -0,0 +1,406 @@
<script setup lang="ts">
/**
* 目录 / 笔记库检索的底部结果面板(IDEA「Find in Path」工具窗的位置)。
*
* # 为什么从搜索卡片里搬出来
*
* 结果列表塞在悬浮卡片里有两个硬伤:卡片宽度有限(预览被截断得厉害),且卡片一关
* 结果就没了 —— 而「先搜完、再逐条点开看」才是这个功能的真实用法。搬到编辑区底部的
* 独立面板后,结果可以一直摆着,边看代码边点下一条。
*
* # 结果点开后会怎样
*
* 面板只管「导航」,不负责判重:命中来自磁盘扫描,文件此刻可能已被外部改动。行号越界
* 由 `EditorHost.jumpToLine` 夹取(跳到近似位置好过整块报错)。
*
* # 历史是「条件」不是「结果」
*
* 点历史条目 = 按原条件**重跑**(见 `editorSearchStore` 的注释)。因此在历史页把鼠标
* 悬在条目上会提示「点击重新检索」,避免用户误以为是快照。
*/
import { computed, ref, watch } from 'vue'
import { ChevronDown, ChevronRight, History, Loader2, RotateCw, SearchX, Trash2, X } from '@lucide/vue'
import { Button } from '@/components/ui/button'
import { ScrollArea } from '@/components/ui/scroll-area'
import { StateBlock } from '@/components/common'
import { useEditorSearchStore, specToQuery, type SearchRecord } from '@/stores/editorSearchStore'
import type { PathSearchFileHits, PathSearchMatch } from '@/types/editor'
const emit = defineEmits<{
/** 打开文件并跳到某行某列 */
'open-file': [payload: { path: string; line: number; column: number }]
}>()
const store = useEditorSearchStore()
const tab = ref<'results' | 'history'>('results')
// ===== 上边缘拖拽调高 =====
//
// 用 Pointer Events + `setPointerCapture`:指针一旦被捕获,即使拖出面板/窗口边界也继续
// 收到 move 事件,不会出现「拖快了就丢手柄」的经典问题(用 mousemove 就得在 window 上
// 挂一堆全局监听与清理)。
const resizing = ref(false)
let dragStartY = 0
let dragStartHeight = 0
function onResizeStart(event: PointerEvent): void {
dragStartY = event.clientY
dragStartHeight = store.panelHeight
resizing.value = true
;(event.currentTarget as HTMLElement).setPointerCapture(event.pointerId)
}
function onResizeMove(event: PointerEvent): void {
if (!resizing.value) return
// 往上拖 = 面板变高(clientY 越小越高)
store.setPanelHeight(dragStartHeight + (dragStartY - event.clientY))
}
function onResizeEnd(event: PointerEvent): void {
if (!resizing.value) return
resizing.value = false
;(event.currentTarget as HTMLElement).releasePointerCapture(event.pointerId)
store.persistPanelHeight()
}
/** 预览切片:切成「命中前 / 命中 / 命中后」三段(永远走插值,不用 v-html)。 */
function pieces(match: PathSearchMatch): Array<{ text: string; hit: boolean }> {
const chars = Array.from(match.preview)
const start = Math.max(0, Math.min(match.matchStart, chars.length))
const end = Math.max(start, Math.min(match.matchEnd, chars.length))
return [
{ text: chars.slice(0, start).join(''), hit: false },
{ text: chars.slice(start, end).join(''), hit: true },
{ text: chars.slice(end).join(''), hit: false }
]
}
const isCollapsed = (path: string): boolean => store.collapsed.includes(path)
// ===== 前端分段显示 =====
//
// 后端把全树命中总数统计完整(`total` 可能上万),但预览条数有上限(`returned`)。
// 就算只渲染 `returned` 条,几千行 DOM 也会让面板滚动卡顿 —— 这里每段只挂
// `PAGE_SIZE` 条,底部「显示更多」续一段;换一次检索结果就回到第一段。
/** 每段渲染的命中条数 */
const PAGE_SIZE = 200
const visibleCount = ref(PAGE_SIZE)
watch(
() => store.results,
() => {
visibleCount.value = PAGE_SIZE
}
)
/** 窗口内的文件切片:窗口耗尽即停,文件内剩余命中不渲染(数据都在,点开就有)。 */
const visibleFiles = computed<Array<{ file: PathSearchFileHits; shown: PathSearchMatch[] }>>(() => {
const r = store.results
if (!r) return []
let budget = visibleCount.value
const out: Array<{ file: PathSearchFileHits; shown: PathSearchMatch[] }> = []
for (const file of r.files) {
if (budget <= 0) break
const shown = file.matches.slice(0, budget)
out.push({ file, shown })
budget -= shown.length
}
return out
})
/** 还有多少条已回传但未渲染的命中(「显示更多」按钮的文案来源)。 */
const remainingCount = computed(() => {
const r = store.results
if (!r) return 0
return Math.max(0, r.returned - visibleCount.value)
})
function showMore(): void {
visibleCount.value += PAGE_SIZE
}
/** 命中数 / 文件数的汇总文案(`total` 是全树统计,不是回传数)。 */
const summary = computed(() => {
const r = store.results
if (!r) return ''
return `${r.total} 处命中 · ${r.totalFiles} 个文件`
})
/** 条件的可读摘要(历史列表与结果页眉都用它,避免两处格式漂移)。 */
function describe(record: {
dir: string
pattern: string
fileTypes: string | null
skipDirs: string
caseSensitive: boolean
wholeWord: boolean
regex: boolean
}): string {
const flags: string[] = []
if (record.caseSensitive) flags.push('Aa')
if (record.wholeWord) flags.push('W')
if (record.regex) flags.push('.*')
const parts = [`「${record.pattern}」`]
if (flags.length) parts.push(flags.join(' '))
if (record.fileTypes) parts.push(record.fileTypes)
return parts.join(' · ')
}
function relativeTime(at: number): string {
const diff = Date.now() - at
const minute = 60_000
if (diff < minute) return '刚刚'
if (diff < 60 * minute) return `${Math.floor(diff / minute)} 分钟前`
if (diff < 24 * 60 * minute) return `${Math.floor(diff / (60 * minute))} 小时前`
return new Date(at).toLocaleDateString()
}
function rerun(record: SearchRecord): void {
tab.value = 'results'
void store.rerunRecord(record.id)
}
/** 重跑当前结果(文件可能已被改动)。 */
function refresh(): void {
const record = store.records.find(r => r.id === store.activeId)
if (!record) return
void store.rerunRecord(record.id)
}
/** 直接以这条记录的条件拼查询串(用于 tooltip 展示搜索目标目录)。 */
function queryOf(record: SearchRecord): string {
return specToQuery(record).dir
}
</script>
<template>
<section
v-if="store.panelOpen"
class="flex shrink-0 flex-col bg-background"
:style="{ height: `${store.panelHeight}px` }"
>
<!--
上边缘:既是「编辑区 / 结果区」的分界线(主题色,够明显),也是拖拽调高的手柄。
手柄本身做厚一点(h-1.5)并带 hover/拖动高亮,否则 2px 的线很难点中。
-->
<div
class="group flex h-1.5 shrink-0 cursor-row-resize touch-none items-center justify-center border-t-2 border-primary/60 bg-primary/5 select-none transition-colors duration-150 hover:bg-primary/20"
:class="resizing && 'bg-primary/25'"
title="拖动调整结果面板高度"
@pointerdown="onResizeStart"
@pointermove="onResizeMove"
@pointerup="onResizeEnd"
@pointercancel="onResizeEnd"
>
<span class="h-0.5 w-10 rounded-full bg-primary/50 group-hover:bg-primary/80" />
</div>
<!-- 页眉:Tab + 当前条件 + 操作 -->
<div class="flex h-8 shrink-0 items-center gap-1 border-b border-border px-2">
<button
type="button"
class="rounded-sm px-2 py-0.5 text-xs transition-colors duration-150"
:class="
tab === 'results'
? 'bg-active font-medium text-foreground'
: 'text-fg-secondary hover:bg-hover hover:text-foreground'
"
@click="tab = 'results'"
>
结果
</button>
<button
type="button"
class="flex items-center gap-1 rounded-sm px-2 py-0.5 text-xs transition-colors duration-150"
:class="
tab === 'history'
? 'bg-active font-medium text-foreground'
: 'text-fg-secondary hover:bg-hover hover:text-foreground'
"
@click="tab = 'history'"
>
<History class="size-3" />历史
<span v-if="store.records.length" class="tabular-nums text-fg-disabled">
{{ store.records.length }}
</span>
</button>
<!-- 结果页眉:条件 + 汇总 + 重跑 -->
<template v-if="tab === 'results'">
<span v-if="store.searching" class="ml-2 flex items-center gap-1.5 text-[11px] text-muted-foreground">
<Loader2 class="size-3 animate-spin" />检索中…
</span>
<template v-else-if="store.error">
<span class="ml-2 min-w-0 truncate text-[11px] text-destructive">{{ store.error }}</span>
</template>
<template v-else-if="store.results">
<span class="ml-2 text-[11px] tabular-nums text-muted-foreground">{{ summary }}</span>
<span
v-if="store.results.truncated"
class="text-[11px] tabular-nums text-warning"
title="为避免拖慢界面,预览只回传了一部分;总数仍是全树统计"
>
(已回传前 {{ store.results.returned }} 条)
</span>
<span
class="ml-2 min-w-0 flex-1 truncate font-mono text-[10px] text-fg-disabled"
:title="store.records.find(r => r.id === store.activeId)?.dir ?? ''"
>
{{ store.records.find(r => r.id === store.activeId)?.dir ?? '' }}
</span>
</template>
</template>
<div class="ml-auto flex shrink-0 items-center gap-0.5">
<Button
v-if="tab === 'results' && store.activeId"
variant="ghost"
size="icon-sm"
title="按原条件重新检索(磁盘内容可能已变)"
@click="refresh"
>
<RotateCw class="size-3.5" />
</Button>
<Button
v-if="tab === 'history' && store.records.length"
variant="ghost"
size="icon-sm"
title="清空全部检索历史"
@click="store.clearRecords()"
>
<Trash2 class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="关闭结果面板" @click="store.panelOpen = false">
<X class="size-3.5" />
</Button>
</div>
</div>
<!-- ===== 结果页 ===== -->
<ScrollArea v-if="tab === 'results'" class="min-h-0 flex-1">
<div v-if="store.results?.files.length" class="px-1.5 py-1">
<div v-for="entry in visibleFiles" :key="entry.file.path">
<button
type="button"
class="flex w-full items-center gap-1.5 rounded-sm px-1.5 py-1 text-left transition-colors duration-150 hover:bg-row-hover"
:title="entry.file.path"
@click="store.toggleFile(entry.file.path)"
>
<component
:is="isCollapsed(entry.file.path) ? ChevronRight : ChevronDown"
class="size-3 shrink-0 opacity-60"
/>
<span class="truncate text-xs font-medium text-foreground">{{ entry.file.name }}</span>
<span
class="shrink-0 text-[10px] tabular-nums"
:class="entry.shown.length < entry.file.totalInFile ? 'text-warning' : 'text-muted-foreground'"
:title="entry.shown.length < entry.file.totalInFile ? `该文件共 ${entry.file.totalInFile} 处命中` : undefined"
>
{{ entry.shown.length < entry.file.totalInFile ? `${entry.shown.length} / ${entry.file.totalInFile}` : entry.file.totalInFile }}
</span>
<span class="ml-auto min-w-0 truncate pl-2 text-[10px] text-fg-disabled">
{{ entry.file.path }}
</span>
</button>
<template v-if="!isCollapsed(entry.file.path)">
<button
v-for="match in entry.shown"
:key="`${entry.file.path}:${match.line}:${match.column}`"
type="button"
class="flex w-full items-center gap-2 rounded-sm py-0.5 pr-1.5 pl-6 text-left transition-colors duration-150 hover:bg-row-hover"
@click="emit('open-file', { path: entry.file.path, line: match.line, column: match.column })"
>
<span class="w-10 shrink-0 text-right text-[10px] tabular-nums text-muted-foreground">
{{ match.line }}
</span>
<span
class="min-w-0 flex-1 overflow-hidden text-ellipsis whitespace-pre font-mono text-[11px] text-fg-secondary"
>
<template v-for="(piece, index) in pieces(match)" :key="index">
<mark
v-if="piece.hit"
class="rounded-xs bg-primary-soft px-0.5 text-primary-soft-text"
>{{ piece.text }}</mark>
<template v-else>{{ piece.text }}</template>
</template>
</span>
</button>
</template>
</div>
<!-- 分段续读:已回传的命中分页渲染,点一次多挂 PAGE_SIZE 条 -->
<button
v-if="remainingCount > 0"
type="button"
class="mx-1.5 my-1 flex w-[calc(100%-12px)] items-center justify-center gap-1 rounded-sm border border-dashed border-border py-1.5 text-xs text-muted-foreground transition-colors duration-150 hover:border-primary/40 hover:bg-row-hover hover:text-foreground"
@click="showMore"
>
显示更多(剩余 {{ remainingCount }} 处)
</button>
</div>
<StateBlock
v-else-if="!store.searching && !store.error && store.results"
variant="empty"
title="没有匹配"
description="换个关键词或调整过滤条件再试"
:min-height="120"
/>
<StateBlock
v-else-if="!store.searching && !store.error"
variant="empty"
title="还没有检索结果"
description="在搜索栏选「目录」或「笔记库」范围,输入关键词后按回车"
:min-height="120"
/>
</ScrollArea>
<!-- ===== 历史页 ===== -->
<ScrollArea v-else class="min-h-0 flex-1">
<div v-if="store.records.length" class="flex flex-col px-1.5 py-1">
<div
v-for="record in store.records"
:key="record.id"
class="group flex items-center gap-2 rounded-sm px-1.5 py-1 transition-colors duration-150 hover:bg-row-hover"
>
<button
type="button"
class="flex min-w-0 flex-1 items-center gap-2 text-left"
:title="`点击按原条件重新检索\n目录:${queryOf(record)}`"
@click="rerun(record)"
>
<SearchX class="size-3.5 shrink-0 opacity-60" />
<span class="min-w-0 flex-1 truncate text-xs text-fg-secondary group-hover:text-foreground">
{{ describe(record) }}
</span>
<span class="shrink-0 text-[10px] tabular-nums text-fg-disabled">
{{ record.hits }} 处 / {{ record.files }} 文件
</span>
<span class="w-16 shrink-0 text-right text-[10px] text-fg-disabled">
{{ relativeTime(record.at) }}
</span>
</button>
<button
type="button"
class="shrink-0 rounded-sm p-0.5 opacity-0 transition-opacity group-hover:opacity-100 hover:bg-active"
title="删除这条历史"
@click="store.removeRecord(record.id)"
>
<X class="size-3" />
</button>
</div>
</div>
<StateBlock
v-else
variant="empty"
title="还没有检索历史"
description="每次在目录 / 笔记库范围检索都会记下条件(只存条件,点击时重新检索)"
:min-height="120"
/>
</ScrollArea>
</section>
</template>
@@ -42,12 +42,12 @@ import {
SelectValue
} from '@/components/ui/select'
import { ConfirmDialog, SettingRow, StateBlock } from '@/components/common'
import { useNotesStore } from '@/stores/notesStore'
import { notesClient } from '../notesClient'
import { useEditorStore } from '@/stores/editorStore'
import { editorClient } from '../editorClient'
import { open } from '@tauri-apps/plugin-dialog'
import type { ConflictPolicy, SyncDirection } from '@/types/notes'
import type { ConflictPolicy, SyncDirection } from '@/types/editor'
const store = useNotesStore()
const store = useEditorStore()
/** 密码输入框(提交后立刻清空,不留内存态) */
const password = ref('')
@@ -113,7 +113,7 @@ async function clearPassword(): Promise<void> {
async function testConnection(): Promise<void> {
testing.value = true
try {
const result = await notesClient.testWebdav()
const result = await editorClient.testWebdav()
if (result.created.length) {
toast.success(`${result.message}(新建了 ${result.created.length} 层目录)`)
} else {
@@ -164,7 +164,7 @@ async function exportLocalSnapshot(): Promise<void> {
filters: [{ name: 'Zip 压缩包', extensions: ['zip'] }]
})
if (typeof dest !== 'string') return
const saved = await notesClient.exportSnapshotLocal(dest)
const saved = await editorClient.exportSnapshotLocal(dest)
toast.success(`快照已导出:${saved}`)
} catch (e) {
toast.error(`导出快照失败:${String(e)}`)
@@ -296,7 +296,7 @@ onMounted(() => {
<CardContent class="!px-4">
<p class="pb-2 text-xs text-muted-foreground">
同步以本地库为准:远端只接收推送与拉取,不作为工作目录。库内
<code class="font-mono">.notes/</code>(索引与同步基线)永不参与同步。
<code class="font-mono">.editor/</code>(索引与同步基线)永不参与同步。
</p>
<div class="flex flex-col divide-y divide-divider">
<SettingRow label="同步方向" :description="DIRECTION_OPTIONS.find(o => o.value === webdav.direction)?.hint" control-width="wide">
+184
View File
@@ -0,0 +1,184 @@
/**
* Classic ASP(`<% ... %>` 内嵌 VBScript)与 ASP.NET(内嵌 C#)的流式语法。
*
* # 为什么要自己拼一层
*
* CM6 没有 ASP 语言包;`@codemirror/legacy-modes` 里只有 `xml`/`html`(标记段)与
* `vbscript`(含 ASP 变体 `vbScriptASP`)、`clike`(含 C#)这些**各自独立**的流式
* 模式。CodeMirror 5 时代靠 `htmlembedded` + `multiplexingMode` 把两者按定界符缝
* 在一起,而 CM6 的 legacy-modes **没有**搬运 multiplexingMode —— 于是这里补上这层
* 「按 `<%` / `%>` 切换子模式」的多路复用。两种 ASP 只有内层语言不同,共用同一套。
*
* # 为什么用流式(StreamLanguage)而不是 lezer
*
* `@codemirror/lang-html` 的 lezer 语法不接受 `<%`:`<` 之后 `%` 不是合法标签名,
* 会被解析成错误节点 —— 无法在其上叠加代码块。流式模式是唯一能复用现成实现的路径,
* 代价是放弃 lezer 的增量语法树。
*
* # 已知取舍(诚实记录,未做未提)
*
* - `<script>` / `<style>` 内部**不**内嵌 JS/CSS:那是 CM5 的 htmlmixed 才有的能力,
* legacy-modes 未提供。
* - 字符串字面量里的 `%>`(如 `x = "%>"`)会提前结束代码块 —— 与 CM5 的
* multiplexingMode 同样的行为,不做特殊处理。
* - 缩进只在标记段沿用 HTML 的规则;代码段每块重建状态,避免沿用上一块的缩进层级。
*/
import {
StreamLanguage,
type IndentContext,
type StreamParser,
type StringStream
} from '@codemirror/language'
import { csharp as csharpStreamMode } from '@codemirror/legacy-modes/mode/clike'
import { html as htmlStream } from '@codemirror/legacy-modes/mode/xml'
import { vbScriptASP } from '@codemirror/legacy-modes/mode/vbscript'
import type { Extension } from '@codemirror/state'
/** 子模式状态:legacy-modes 的状态是不透明对象,这里只保证能浅拷贝。 */
type SubState = Record<string, unknown>
/** 多路复用状态:当前由谁出 token,以及两个子模式各自的内部状态。 */
interface AspState {
/** html = 标记段;asp = `<% ... %>` 代码段;comment = `<%-- ... --%>` 注释段 */
mode: 'html' | 'asp' | 'comment'
/** html/xml 流式模式的状态 */
outer: SubState
/** 代码段流式模式的状态(每个 `<% ... %>` 块重新开一个) */
inner: SubState
}
// legacy-modes 的导出类型是 `StreamParser<unknown>`,这里收窄成可操作的形状
const htmlMode = htmlStream as unknown as StreamParser<SubState>
/** `<% ... %>` 内层:Classic ASP 用 VBScript(含下面的 `:` 误报修正) */
const vbMode = vbsStream()
/** `<% ... %>` 内层:ASP.NET 用 C#(legacy 词法器,理由见 `aspx()`) */
const csharpMode = csharpStreamMode as unknown as StreamParser<SubState>
/**
* VBScript 流式解析器(legacy-modes 的 `vbScript` 加一层**误报修正**)。
*
* 老式 vbscript 词法器把语句分隔符 `:`(VB 里既用于 `a = 1 : b = 2` 也用于 `Label:`)
* 判成 `error`,而 `@codemirror/language` 把 `error` 解析成 `invalid` 标签、兜底高亮
* 又给 invalid 配了红色 —— 结果每个 .vbs / .asp 里都会飘红。编辑器不是 linter,
* 这种误报比「不上色」更糟,因此在 token 层面统一降级为「无高亮」。
*
* 挂在 token 输出上而不是自己重写词法器:`:` 在词法器内部还会驱动状态机(缩进、
* `doInCurrentLine` 等),重写容易错;只改输出的样式名是零风险的。
*/
function vbsStream(): StreamParser<SubState> {
const inner = vbScriptASP as unknown as StreamParser<SubState>
return {
name: inner.name,
startState: unit => inner.startState?.(unit) ?? {},
copyState: state => inner.copyState?.(state) ?? { ...state },
token(stream: StringStream, state: SubState) {
const style = inner.token(stream, state)
return style === 'error' || style === 'invalid' ? null : style
},
indent: (state, textAfter, context) => inner.indent?.(state, textAfter, context) ?? null,
blankLine: (state, unit) => inner.blankLine?.(state, unit),
languageData: inner.languageData
}
}
const OPEN = '<%'
const CLOSE = '%>'
const COMMENT_OPEN = '--'
const COMMENT_CLOSE = '--%>'
function startSub(parser: StreamParser<SubState>): SubState {
return parser.startState?.(2) ?? {}
}
function createAsp(name: string, innerMode: StreamParser<SubState>): StreamParser<AspState> {
return {
name,
startState: () => ({
mode: 'html',
outer: startSub(htmlMode),
inner: startSub(innerMode)
}),
copyState: state => ({
mode: state.mode,
outer: htmlMode.copyState?.(state.outer) ?? { ...state.outer },
inner: innerMode.copyState?.(state.inner) ?? { ...state.inner }
}),
token(stream: StringStream, state: AspState) {
// `<%-- ... --%>`:ASP 注释,整段按注释着色
if (state.mode === 'comment') {
if (stream.match(COMMENT_CLOSE)) {
state.mode = 'html'
return 'meta'
}
// 未到行尾时至少吞掉一个字符(`skipTo` 命中则停在定界符之前)
if (!stream.skipTo(COMMENT_CLOSE)) stream.skipToEnd()
return 'comment'
}
// `<% ... %>`:交给内层语言。`%>` 必须在**委托之前**先判 —— VBScript 的运算符
// 集合不含 `%`,一旦让它先吃,`%` 会被当成 error 吞掉,块就再也关不上
if (state.mode === 'asp') {
if (stream.match(CLOSE)) {
state.mode = 'html'
return 'meta'
}
const before = stream.pos
const style = innerMode.token(stream, state.inner)
if (stream.pos === before) stream.next() // 兜底:保证流一定前进
return style
}
// 标记段:先看是不是 `<%` 开头的代码块,否则原样交给 html 流式模式
if (stream.match(OPEN)) {
if (stream.match(COMMENT_OPEN)) {
state.mode = 'comment'
return 'comment'
}
// `<%@ ... %>` 是页面指令(Language / CodePage 等)。把 `@` 一并按 meta 吃掉,
// 否则内层语言会把它判成 error,在每页首行留一个红点
stream.match('@')
state.mode = 'asp'
state.inner = startSub(innerMode) // 每块独立状态:块间缩进不互相污染
return 'meta'
}
return htmlMode.token(stream, state.outer)
},
indent(state: AspState, textAfter: string, context: IndentContext): number | null {
if (state.mode === 'html') return htmlMode.indent?.(state.outer, textAfter, context) ?? null
return null
},
languageData: htmlMode.languageData
}
}
/** Classic ASP(`.asp` / `.asa`):`<% %>` 内是 VBScript。 */
export function asp(): Extension {
return StreamLanguage.define(createAsp('asp', vbMode))
}
/**
* 独立 VBScript(`.vbs`):不套 HTML 多路复用,直接用修正过误报的流式解析。
*
* 放在这里而不是在 `languages.ts` 里直接 `StreamLanguage.define(vbScriptASP)`,
* 是为了和 ASP 共用同一份修正(`vbsStream()`),避免两处行为漂移。
*/
export function vbs(): Extension {
return StreamLanguage.define(vbMode)
}
/**
* ASP.NET(`.aspx` / `.ascx` / `.ashx` …):`<% %>` 内通常是 C#。
*
* 内层用的是 legacy-modes 的 C# **词法器**,而不是 `.cs` 文件用的
* `@replit/codemirror-lang-csharp` —— 后者是 lezer 语法,没法塞进流式多路复用里。
* 取舍:`.aspx` 内联代码块的精度弱于 `.cs` 文件,但 HTML 结构与代码块都能着色,
* 好过整篇按纯文本 / 把 `<% %>` 当 HTML 错误节点处理。
*/
export function aspx(): Extension {
return StreamLanguage.define(createAsp('aspx', csharpMode))
}
@@ -36,9 +36,9 @@ import {
defaultHighlightStyle
} from '@codemirror/language'
import { closeBrackets, closeBracketsKeymap } from '@codemirror/autocomplete'
import { highlightSelectionMatches, searchKeymap } from '@codemirror/search'
import { highlightSelectionMatches, search } from '@codemirror/search'
import { notesKeymap } from './keymap'
import { editorKeymap } from './keymap'
import { markdownLivePreview } from './markdownLivePreview'
import { editorTypography, resolveEditorTheme } from './themes'
import { wikilinkExtension, type WikilinkHandlers } from './wikilink'
@@ -103,7 +103,12 @@ const baseExtensions: Extension = [
EditorState.allowMultipleSelections.of(true),
indentOnInput(),
highlightActiveLine(),
highlightSelectionMatches(),
// `highlightSelectionMatches` 在 heavyExtensions 里:它随选区变化全量扫描,
// 大文件中是可感知的输入延迟来源,跟折叠 / 补全一起降载
// 搜索状态 + 命中高亮。这里**只**引入状态字段,不绑 `searchKeymap`:
// 自带搜索面板已由统一搜索器(EditorSearch.vue)取代,Ctrl+F 由窗口级按键接管,
// 面板只在显式 `openSearchPanel` 时才出现 —— 于是它永远不会出现。
search(),
rectangularSelection(),
crosshairCursor(),
// 兜底高亮:自建主题自带 HighlightStyle,但 Stream/未知语言可能没有对应标签,
@@ -115,7 +120,13 @@ const baseExtensions: Extension = [
/** 重扩展(大文件时全部关闭)。 */
function heavyExtensions(config: EditorConfig): Extension {
if (config.largeFile) return []
const parts: Extension[] = [bracketMatching(), foldGutter()]
const parts: Extension[] = [
bracketMatching(),
foldGutter(),
// 选区匹配高亮(所有选区出现处/全文档同词)每次选区变化都要全量扫描,
// 大文件里选中一段文字就能把输入拖出可感知的延迟 —— 归入重扩展
highlightSelectionMatches()
]
if (config.autocomplete) parts.push(closeBrackets())
return parts
}
@@ -172,10 +183,9 @@ export function createEditorState(options: {
heavyCompartment.of(c.heavy),
wikilinkCompartment.of(c.wikilink),
keymap.of([
...notesKeymap,
...editorKeymap,
...closeBracketsKeymap,
...defaultKeymap,
...searchKeymap,
...historyKeymap,
...foldKeymap,
indentWithTab
@@ -18,7 +18,7 @@
* 缓存不主动失效:用户替换了同名图片的场景很罕见,而「每 3 秒清一次缓存」会让
* 滚动长文档时反复读盘。切库时由 `resetImageCache()` 清空。
*/
import { notesClient } from '../notesClient'
import { editorClient } from '../editorClient'
/** 缓存:库内相对路径 → data URL(`null` = 已确认不可预览) */
const cache = new Map<string, string | null>()
@@ -39,7 +39,7 @@ export function cachedImage(relPath: string): string | null | undefined {
/**
* 解析 Markdown 图片目标为「库内相对路径」。
*
* 规则与 `notes_read_asset` 的安全模型一致:
* 规则与 `editor_read_asset` 的安全模型一致:
* - 绝对 URL(`http://` / `https://` / `data:`)→ `null`(外链不内联,交给浏览器);
* - 以 `/` 开头 → 视为**库根相对**路径;
* - 其余 → 相对当前笔记所在目录解析,支持 `./` 与 `../`。
@@ -86,7 +86,7 @@ export async function fetchImage(relPath: string): Promise<string | null> {
const pending = inflight.get(relPath)
if (pending) return pending
const task = notesClient
const task = editorClient
.readAsset(relPath)
.then(value => {
cache.set(relPath, value)
@@ -106,7 +106,7 @@ const insertCodeBlock: Command = view => {
}
/** 编辑器快捷键(优先级高于全局快捷键)。 */
export const notesKeymap: KeyBinding[] = [
export const editorKeymap: KeyBinding[] = [
{ key: 'Mod-b', run: wrapSelection('**'), preventDefault: true },
{ key: 'Mod-i', run: wrapSelection('*'), preventDefault: true },
{ key: 'Mod-Shift-x', run: wrapSelection('~~'), preventDefault: true },
@@ -122,7 +122,7 @@ export const notesKeymap: KeyBinding[] = [
]
/** 供工具栏按钮调用的命令集合。 */
export const notesCommands = {
export const editorCommands = {
bold: wrapSelection('**'),
italic: wrapSelection('*'),
strikethrough: wrapSelection('~~'),
+461
View File
@@ -0,0 +1,461 @@
/**
* 语言支持:扩展名 → CM6 语言扩展,**按需动态加载**。
*
* # 为什么必须懒加载
*
* `@codemirror/language-data` 的便利之处是「一个入口拿到所有语言」,代价是把
* 30 多个语言包全挂在依赖图上。若静态 `import`,Vite 会把它们塞进主 chunk ——
* 本项目首屏还要承载模块系统、终端、音乐等一堆东西,没有余量给「可能永远用不到
* 的 .cpp 语法」。这里手写一张显式映射表,每个语言一个 `import()`,Vite 自动切成
* 独立 chunk:用户打开 `.rs` 才下载 rust 的解析器(约 10~30 kB)。
*
* # 为什么不用 languageData 的 `LanguageDescription.matchFilename`
*
* 那个 API 是给「Markdown 内嵌代码块」用的,它按 name/alias 匹配,覆盖不到
* `.vue`、`.toml`、`.ps1` 这类扩展名(以及一大批我们想要的别名)。手写表虽然
* 啰嗦,但**行为完全可预期**:前端没有「这个扩展名到底映射到哪个语言」的推理,
* 只有一张查表。
*
* # 围栏代码块的内嵌高亮(P5-3)
*
* `markdown({ codeLanguages })` 接受 language-data 的语言清单,让 ```rust 这类
* 围栏代码块按 info 串内嵌高亮。清单本身要异步 `import()`,而 `markdown()` 是同步
* 构建设置的 —— 解法是把整个 markdown 加载器变成异步(`LanguageLoader` 本就允许
* 返回 Promise,`EditorHost.applyLanguage` 会 await),因此没有额外抖动。
*
* # 第三方语言包
*
* 官方 lezer 包(`@codemirror/lang-*`)之外的缺口,按需引入:
* - `@replit/codemirror-lang-csharp`:C#(npm 上没有官方 `@codemirror/lang-csharp`);
* - `@replit/codemirror-lang-svelte`、`codemirror-lang-elixir`、`codemirror-lang-makefile`:
* 这三个语言在 legacy-modes 里没有可用模式,只能靠社区包;
* - 其余全部走 `@codemirror/legacy-modes` 的流式解析(`StreamLanguage`)。
*
* # 未内置的语言
*
* 表格之外的一律退回纯文本(不加载任何扩展)。
* - `Dockerfile` / `Containerfile` / `Makefile` / `Gemfile` 等:按完整文件名匹配;
* - `.asp` / `.aspx`:没有现成语言包,用自建的多路复用(HTML + 代码块),见 `aspMode.ts`;
* - 其余未知扩展名:纯文本。
*
* 统一原则:宁可「没高亮但能正常编辑」,也不要「高亮错乱」。
*/
import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
import { StreamLanguage } from '@codemirror/language'
import { GFM } from '@lezer/markdown'
import { type Extension } from '@codemirror/state'
/**
* 语言加载器:返回扩展(可同步、可异步)。
*
* **允许返回 `null`**:表示「这个文件没有内置语言」。用 `null` 而不是空数组表达
* 「本来就没有」,是为了让调用方(`EditorHost`)能在日志里区分「没有语言」与
* 「有语言但被卸下」;两者在 CM6 的 Compartment 里行为相同,但语义不同。
*/
export type LanguageLoader = () => Extension | null | Promise<Extension | null>
interface LanguageEntry {
/** 状态栏展示名 */
label: string
load: LanguageLoader
}
/**
* 多扩展名 / 多文件名共用的条目。
*
* 同一个语言常被多个扩展名(或「扩展名 + 完整文件名」)映射,例如 Clojure 的
* `clj/cljs/cljc/edn`、F# 的 `fs/fsi/fsx`、ASP.NET 的 `aspx/ascx/ashx/asmx/asax`,
* 以及 Ruby / Groovy / CMake / Makefile 那种「扩展名 + 无扩展名的约定文件名」。
* 写成共享常量只保留一份 thunk,避免同一行 `import()` 复制四五遍。
*
* `const` 不像函数声明那样提升,因此这一块必须放在 `LOADERS` / `FILENAME_LOADERS` 之前。
*/
const SVELTE: LanguageEntry = {
label: 'Svelte',
load: () => import('@replit/codemirror-lang-svelte').then(m => m.svelte())
}
/** ASP.NET 页面 / 用户控件 / 处理器 / Web 服务 / 全局应用类(`<% %>` 内按 C# 处理) */
const ASPNET: LanguageEntry = {
label: 'ASP.NET',
load: () => import('./aspMode').then(m => m.aspx())
}
const RUBY: LanguageEntry = {
label: 'Ruby',
load: () => stream(() => import('@codemirror/legacy-modes/mode/ruby'), m => m.ruby)
}
const GROOVY: LanguageEntry = {
label: 'Groovy',
load: () => stream(() => import('@codemirror/legacy-modes/mode/groovy'), m => m.groovy)
}
const FSHARP: LanguageEntry = {
label: 'F#',
load: () => stream(() => import('@codemirror/legacy-modes/mode/mllike'), m => m.fSharp)
}
const CLOJURE: LanguageEntry = {
label: 'Clojure',
load: () => stream(() => import('@codemirror/legacy-modes/mode/clojure'), m => m.clojure)
}
const VERILOG: LanguageEntry = {
label: 'Verilog',
load: () => stream(() => import('@codemirror/legacy-modes/mode/verilog'), m => m.verilog)
}
const FORTRAN: LanguageEntry = {
label: 'Fortran',
load: () => stream(() => import('@codemirror/legacy-modes/mode/fortran'), m => m.fortran)
}
const COMMON_LISP: LanguageEntry = {
label: 'Lisp',
load: () => stream(() => import('@codemirror/legacy-modes/mode/commonlisp'), m => m.commonLisp)
}
const CMAKE: LanguageEntry = {
label: 'CMake',
load: () => stream(() => import('@codemirror/legacy-modes/mode/cmake'), m => m.cmake)
}
const MAKEFILE: LanguageEntry = {
label: 'Makefile',
load: () => import('codemirror-lang-makefile').then(m => m.makefile())
}
/**
* 扩展名(小写,不含点)→ 语言。
*
* 值写成 thunk 而不是已加载的扩展:`import()` 只在真正调用时执行,
* 表本身的构建不产生任何网络/打包开销。
*/
const LOADERS: Record<string, LanguageEntry> = {
// ===== 前端 =====
js: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
mjs: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
cjs: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
jsx: { label: 'JSX', load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ jsx: true })) },
ts: { label: 'TypeScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ typescript: true })) },
mts: { label: 'TypeScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ typescript: true })) },
cts: { label: 'TypeScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ typescript: true })) },
tsx: {
label: 'TSX',
load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ typescript: true, jsx: true }))
},
vue: { label: 'Vue', load: () => import('@codemirror/lang-vue').then(m => m.vue()) },
svelte: SVELTE,
html: { label: 'HTML', load: () => import('@codemirror/lang-html').then(m => m.html()) },
htm: { label: 'HTML', load: () => import('@codemirror/lang-html').then(m => m.html()) },
// Handlebars 本质是 HTML + `{{ }}` 插值,没有专门语言包,按 HTML 着色
hbs: { label: 'Handlebars', load: () => import('@codemirror/lang-html').then(m => m.html()) },
handlebars: { label: 'Handlebars', load: () => import('@codemirror/lang-html').then(m => m.html()) },
// Classic ASP:`<% %>` 内是 VBScript。没有现成语言包,用自建的多路复用,见 `aspMode.ts`
asp: { label: 'ASP', load: () => import('./aspMode').then(m => m.asp()) },
asa: { label: 'ASP', load: () => import('./aspMode').then(m => m.asp()) },
aspx: ASPNET,
ascx: ASPNET,
ashx: ASPNET,
asmx: ASPNET,
asax: ASPNET,
css: { label: 'CSS', load: () => import('@codemirror/lang-css').then(m => m.css()) },
scss: { label: 'SCSS', load: () => import('@codemirror/lang-sass').then(m => m.sass()) },
sass: {
label: 'Sass',
load: () => import('@codemirror/lang-sass').then(m => m.sass({ indented: true }))
},
less: { label: 'Less', load: () => import('@codemirror/lang-less').then(m => m.less()) },
// ===== 数据与配置 =====
json: { label: 'JSON', load: () => import('@codemirror/lang-json').then(m => m.json()) },
jsonc: { label: 'JSON', load: () => import('@codemirror/lang-json').then(m => m.json()) },
yaml: { label: 'YAML', load: () => import('@codemirror/lang-yaml').then(m => m.yaml()) },
yml: { label: 'YAML', load: () => import('@codemirror/lang-yaml').then(m => m.yaml()) },
xml: xmlLike('XML'),
svg: xmlLike('SVG'),
xhtml: xmlLike('XHTML'),
xsd: xmlLike('XML Schema'),
xsl: xmlLike('XSL'),
xslt: xmlLike('XSLT'),
xaml: xmlLike('XAML'),
plist: xmlLike('Property List'),
rss: xmlLike('RSS'),
atom: xmlLike('Atom'),
wsdl: xmlLike('WSDL'),
// .NET / MSBuild 生态:工程文件与资源配置本质都是 XML
csproj: xmlLike('MSBuild'),
vbproj: xmlLike('MSBuild'),
fsproj: xmlLike('MSBuild'),
props: xmlLike('MSBuild'),
targets: xmlLike('MSBuild'),
nuspec: xmlLike('NuGet'),
resx: xmlLike('ResX'),
config: xmlLike('XML'),
sql: { label: 'SQL', load: () => import('@codemirror/lang-sql').then(m => m.sql()) },
// ===== 后端与系统 =====
py: { label: 'Python', load: () => import('@codemirror/lang-python').then(m => m.python()) },
pyw: { label: 'Python', load: () => import('@codemirror/lang-python').then(m => m.python()) },
php: { label: 'PHP', load: () => import('@codemirror/lang-php').then(m => m.php()) },
phtml: { label: 'PHP', load: () => import('@codemirror/lang-php').then(m => m.php()) },
rs: { label: 'Rust', load: () => import('@codemirror/lang-rust').then(m => m.rust()) },
go: { label: 'Go', load: () => import('@codemirror/lang-go').then(m => m.go()) },
java: { label: 'Java', load: () => import('@codemirror/lang-java').then(m => m.java()) },
// C# 用社区 lezer 包:npm 上没有官方 `@codemirror/lang-csharp`,官方
// `@codemirror/language-data` 自己也是退回 legacy-modes 的 clike 词法器 —— 那个精度
// 明显不如真正的语法分析(拿不到类型/方法定义等语义标签),所以这里换第三方包
cs: { label: 'C#', load: () => import('@replit/codemirror-lang-csharp').then(m => m.csharp()) },
kt: { label: 'Kotlin', load: () => stream(() => import('@codemirror/legacy-modes/mode/clike'), m => m.kotlin) },
kts: { label: 'Kotlin', load: () => stream(() => import('@codemirror/legacy-modes/mode/clike'), m => m.kotlin) },
scala: { label: 'Scala', load: () => stream(() => import('@codemirror/legacy-modes/mode/clike'), m => m.scala) },
sc: { label: 'Scala', load: () => stream(() => import('@codemirror/legacy-modes/mode/clike'), m => m.scala) },
dart: { label: 'Dart', load: () => stream(() => import('@codemirror/legacy-modes/mode/clike'), m => m.dart) },
// `.mm` = Objective-C++(`.m` 语义歧义太大 —— MATLAB / Mathematica / Objective-C 都用它,不猜)
mm: {
label: 'Objective-C++',
load: () => stream(() => import('@codemirror/legacy-modes/mode/clike'), m => m.objectiveCpp)
},
groovy: GROOVY,
gradle: GROOVY,
fs: FSHARP,
fsi: FSHARP,
fsx: FSHARP,
c: { label: 'C', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
h: { label: 'C/C++ Header', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
cc: { label: 'C++', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
cpp: { label: 'C++', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
cxx: { label: 'C++', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
hpp: { label: 'C++ Header', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
// ===== 脚本与配置(经 legacy-modes 的流式解析,P5-1) =====
sh: { label: 'Shell', load: () => stream(() => import('@codemirror/legacy-modes/mode/shell'), m => m.shell) },
bash: { label: 'Shell', load: () => stream(() => import('@codemirror/legacy-modes/mode/shell'), m => m.shell) },
zsh: { label: 'Shell', load: () => stream(() => import('@codemirror/legacy-modes/mode/shell'), m => m.shell) },
ps1: {
label: 'PowerShell',
load: () => stream(() => import('@codemirror/legacy-modes/mode/powershell'), m => m.powerShell)
},
psm1: {
label: 'PowerShell',
load: () => stream(() => import('@codemirror/legacy-modes/mode/powershell'), m => m.powerShell)
},
// VBScript / VB.NET(与 ASP 同族,但独立文件按纯脚本高亮,不套 HTML 多路复用)。
// VBScript 用裹了一层词法修正的 vbScript(原版把语句分隔符 `:` 当 error 涂红)——
// 见 `vbsStream()` 注释;ASP 的多路复用内部复用了同一个修正版
vbs: { label: 'VBScript', load: () => import('./aspMode').then(m => m.vbs()) },
vb: { label: 'VB.NET', load: () => stream(() => import('@codemirror/legacy-modes/mode/vb'), m => m.vb) },
toml: { label: 'TOML', load: () => stream(() => import('@codemirror/legacy-modes/mode/toml'), m => m.toml) },
ini: {
label: 'INI',
load: () => stream(() => import('@codemirror/legacy-modes/mode/properties'), m => m.properties)
},
cfg: {
label: 'INI',
load: () => stream(() => import('@codemirror/legacy-modes/mode/properties'), m => m.properties)
},
conf: {
label: 'INI',
load: () => stream(() => import('@codemirror/legacy-modes/mode/properties'), m => m.properties)
},
properties: {
label: 'INI',
load: () => stream(() => import('@codemirror/legacy-modes/mode/properties'), m => m.properties)
},
dockerfile: {
label: 'Dockerfile',
load: () => stream(() => import('@codemirror/legacy-modes/mode/dockerfile'), m => m.dockerFile)
},
// ===== 更多常见语言(全部经 legacy-modes 的流式解析) =====
//
// 这些语言在 npm 上都没有可用的 CM6 lezer 包(官方 `language-data` 对它们同样是
// 退回 legacy-modes)。统一原则不变:宁可「基础但可用」,也不要「精确但会错乱」。
rb: RUBY,
lua: { label: 'Lua', load: () => stream(() => import('@codemirror/legacy-modes/mode/lua'), m => m.lua) },
pl: { label: 'Perl', load: () => stream(() => import('@codemirror/legacy-modes/mode/perl'), m => m.perl) },
pm: { label: 'Perl', load: () => stream(() => import('@codemirror/legacy-modes/mode/perl'), m => m.perl) },
r: { label: 'R', load: () => stream(() => import('@codemirror/legacy-modes/mode/r'), m => m.r) },
swift: { label: 'Swift', load: () => stream(() => import('@codemirror/legacy-modes/mode/swift'), m => m.swift) },
jl: { label: 'Julia', load: () => stream(() => import('@codemirror/legacy-modes/mode/julia'), m => m.julia) },
ex: { label: 'Elixir', load: () => import('codemirror-lang-elixir').then(m => m.elixir()) },
exs: { label: 'Elixir', load: () => import('codemirror-lang-elixir').then(m => m.elixir()) },
erl: { label: 'Erlang', load: () => stream(() => import('@codemirror/legacy-modes/mode/erlang'), m => m.erlang) },
hrl: { label: 'Erlang', load: () => stream(() => import('@codemirror/legacy-modes/mode/erlang'), m => m.erlang) },
hs: { label: 'Haskell', load: () => stream(() => import('@codemirror/legacy-modes/mode/haskell'), m => m.haskell) },
clj: CLOJURE,
cljs: CLOJURE,
cljc: CLOJURE,
edn: CLOJURE,
elm: { label: 'Elm', load: () => stream(() => import('@codemirror/legacy-modes/mode/elm'), m => m.elm) },
d: { label: 'D', load: () => stream(() => import('@codemirror/legacy-modes/mode/d'), m => m.d) },
cr: { label: 'Crystal', load: () => stream(() => import('@codemirror/legacy-modes/mode/crystal'), m => m.crystal) },
coffee: {
label: 'CoffeeScript',
load: () => stream(() => import('@codemirror/legacy-modes/mode/coffeescript'), m => m.coffeeScript)
},
hx: { label: 'Haxe', load: () => stream(() => import('@codemirror/legacy-modes/mode/haxe'), m => m.haxe) },
pas: { label: 'Pascal', load: () => stream(() => import('@codemirror/legacy-modes/mode/pascal'), m => m.pascal) },
dpr: { label: 'Pascal', load: () => stream(() => import('@codemirror/legacy-modes/mode/pascal'), m => m.pascal) },
scm: { label: 'Scheme', load: () => stream(() => import('@codemirror/legacy-modes/mode/scheme'), m => m.scheme) },
ss: { label: 'Scheme', load: () => stream(() => import('@codemirror/legacy-modes/mode/scheme'), m => m.scheme) },
lisp: COMMON_LISP,
cl: COMMON_LISP,
el: COMMON_LISP,
tcl: { label: 'Tcl', load: () => stream(() => import('@codemirror/legacy-modes/mode/tcl'), m => m.tcl) },
cmake: CMAKE,
mk: MAKEFILE,
proto: {
label: 'Protocol Buffers',
load: () => stream(() => import('@codemirror/legacy-modes/mode/protobuf'), m => m.protobuf)
},
diff: { label: 'Diff', load: () => stream(() => import('@codemirror/legacy-modes/mode/diff'), m => m.diff) },
patch: { label: 'Diff', load: () => stream(() => import('@codemirror/legacy-modes/mode/diff'), m => m.diff) },
dtd: { label: 'DTD', load: () => stream(() => import('@codemirror/legacy-modes/mode/dtd'), m => m.dtd) },
v: VERILOG,
sv: VERILOG,
svh: VERILOG,
vhd: { label: 'VHDL', load: () => stream(() => import('@codemirror/legacy-modes/mode/vhdl'), m => m.vhdl) },
vhdl: { label: 'VHDL', load: () => stream(() => import('@codemirror/legacy-modes/mode/vhdl'), m => m.vhdl) },
f: FORTRAN,
for: FORTRAN,
f77: FORTRAN,
f90: FORTRAN,
f95: FORTRAN,
s: { label: 'Assembly', load: () => stream(() => import('@codemirror/legacy-modes/mode/gas'), m => m.gas) },
nsi: { label: 'NSIS', load: () => stream(() => import('@codemirror/legacy-modes/mode/nsis'), m => m.nsis) },
nsh: { label: 'NSIS', load: () => stream(() => import('@codemirror/legacy-modes/mode/nsis'), m => m.nsis) }
}
/**
* 按**完整文件名**(小写,不含路径)匹配的语言(无扩展名或需要整名匹配的场景)。
*/
const FILENAME_LOADERS: Record<string, LanguageEntry> = {
dockerfile: {
label: 'Dockerfile',
load: () => stream(() => import('@codemirror/legacy-modes/mode/dockerfile'), m => m.dockerFile)
},
containerfile: {
label: 'Dockerfile',
load: () => stream(() => import('@codemirror/legacy-modes/mode/dockerfile'), m => m.dockerFile)
},
// 约定文件名(无扩展名,按扩展名永远匹配不到)
makefile: MAKEFILE,
gnumakefile: MAKEFILE,
gemfile: RUBY,
rakefile: RUBY,
vagrantfile: RUBY,
jenkinsfile: GROOVY,
'cmakelists.txt': CMAKE,
// nginx 的配置文件名固定,但扩展名 `.conf` 已被 INI 占用 —— 只有整名匹配才不误判
'nginx.conf': {
label: 'Nginx',
load: () => stream(() => import('@codemirror/legacy-modes/mode/nginx'), m => m.nginx)
}
}
/**
* XML 家族共用一个语言条目(lang-xml 对 XML 各变体的解析是一致的,只有展示名不同)。
*
* 写成函数是为了不在表里重复十几遍同样的 `import()`;函数声明提升,因此放在
* `LOADERS` 之后也安全(`stream` 同此)。
*/
function xmlLike(label: string): LanguageEntry {
return { label, load: () => import('@codemirror/lang-xml').then(m => m.xml()) }
}
/**
* 用 legacy-modes 的流式解析构造扩展。
*
* StreamLanguage 的 token 名与 Lezer 高亮标签并非一一对应,但 `@codemirror/language`
* 的内置映射已覆盖常见 token;配合 `core.ts` 的 `defaultHighlightStyle` 兜底,
* 得到的是「可用的基础高亮」而非精确语义高亮。
*/
async function stream(
load: () => Promise<{ [key: string]: unknown }>,
pick: (mod: { [key: string]: unknown }) => unknown
): Promise<Extension> {
const mod = await load()
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return StreamLanguage.define(pick(mod) as any)
}
/** 语言缓存:同一个语言只解析一次,之后复用已加载的扩展。 */
const cache = new Map<string, Promise<Extension | null>>()
/** 从文件名取扩展名(小写、不含点;无扩展名返回空串)。 */
export function extensionOf(fileName: string): string {
const base = fileName.split(/[\\/]/).pop() ?? ''
const dot = base.lastIndexOf('.')
if (dot <= 0 || dot === base.length - 1) return ''
return base.slice(dot + 1).toLowerCase()
}
/** 解析文件名对应的语言条目(先按完整文件名,再按扩展名)。 */
function resolveEntry(fileName: string): { key: string; entry: LanguageEntry } | null {
const base = (fileName.split(/[\\/]/).pop() ?? '').toLowerCase()
const byName = FILENAME_LOADERS[base]
if (byName) return { key: `fn:${base}`, entry: byName }
const ext = extensionOf(fileName)
const byExt = LOADERS[ext]
if (byExt) return { key: `ext:${ext}`, entry: byExt }
return null
}
/** 该文件名是否有内置语言支持。 */
export function hasLanguage(fileName: string): boolean {
return resolveEntry(fileName) !== null
}
/** 文件名对应的语言展示信息(无支持时返回「纯文本」)。 */
export function languageLabel(fileName: string): string {
return resolveEntry(fileName)?.entry.label ?? '纯文本'
}
/**
* 解析文件名对应的语言扩展。
*
* 返回 `null` 表示「没有内置语言」——调用方据此保持纯文本,而不是传空数组:
* 空数组与 `null` 在 Compartment 里语义相同,但 `null` 表达的是「本来就没有」,
* 而 `[]` 表达的是「有语言但选了无」,两者的日志与调试含义不同。
*/
export async function loadLanguage(fileName: string): Promise<Extension | null> {
const resolved = resolveEntry(fileName)
if (!resolved) return null
const cached = cache.get(resolved.key)
if (cached) return cached
const pending = Promise.resolve(resolved.entry.load()).catch(error => {
// 加载失败(离线 / chunk 404)时**不要**把失败的 promise 留在缓存里:
// 用户重连后再打开同一类型文件应当能成功
cache.delete(resolved.key)
throw error
})
cache.set(resolved.key, pending)
return pending
}
/**
* 笔记(Markdown)模式的语言扩展。
*
* # 为什么显式加 GFM 扩展
*
* `markdown()` 默认只用**基础 CommonMark** 语法:表格(`| a | b |`)、任务列表
* (`- [ ]`)、删除线(`~~x~~`)都不会被解析成对应节点,于是
* - Live Preview 拿不到 `Table` / `TaskMarker` 节点,表格与复选框渲染不出来;
* - 大纲提取虽然是自己扫文本(不依赖语法树),但**编辑器内的**高亮与折叠也会缺一块。
*
* `@lezer/markdown` 导出 `GFM`(= Table + TaskList + Strikethrough + Autolink 的扩展包),
* 交给 `extensions` 即可。注意它只影响**解析**,不改变渲染 —— 渲染仍由
* `markdownLivePreview.ts` 的装饰负责。
*
* 与代码文件走同一条 `loadLanguage` 通道(`md` → Markdown),因此笔记与代码
* 在「语言如何装配」上没有第二条路径。
*/
export function markdownLoader(): LanguageLoader {
// 返回 Promise(LanguageLoader 允许异步):内嵌代码块高亮需要 language-data 的
// 语言清单,而 `markdown()` 是同步构建设置的 —— 把清单的 `import()` 放到异步阶段,
// `EditorHost` 的 `applyLanguage` 本就会 await 语言加载器,因此没有额外抖动。
return async () => {
const { languages } = await import('@codemirror/language-data')
return markdown({
base: markdownLanguage,
extensions: GFM,
// ```rust 之类围栏代码块按 info 串匹配语言并内嵌高亮(P5-3)
codeLanguages: languages
})
}
}
@@ -51,7 +51,7 @@
* 3. 任何一步抛错都退化成「转义后的纯文本」,高亮失败绝不影响正文。
*
* 这里用 `highlight.js` 全量包(190+ 语言,同步可用,任何 info string 都有机会命中)。
* 代价是 NotesWindow chunk 变大:在 Tauri 里它从本地磁盘加载,换「```toml /
* 代价是 EditorWindow chunk 变大:在 Tauri 里它从本地磁盘加载,换「```toml /
* ```powershell / ```diff 也有高亮」是划算的。若哪天 chunk 预算吃紧,换成
* `highlight.js/lib/core` + 精选语言注册即可,其余逻辑一行都不用动。
*
@@ -85,7 +85,7 @@ export interface NoteHtmlInput {
* 是否对围栏代码块做语法高亮(默认 `true`)。
*
* 关掉它的场景是「打印」:黑白打印机上浅色 token 常常淡到看不见,而不上色至少是
* 稳定的黑字。对应设置项 `NoteSettings.exportHighlight`。
* 稳定的黑字。对应设置项 `EditorSettings.exportHighlight`。
*/
highlight?: boolean
}
File renamed without changes.
@@ -13,7 +13,7 @@
* - **配色**(本文件的 `createTheme` / `oneDark`):只负责颜色,是 CM6 的 `Extension`。
* - **排版**([`editorTypography`]):字体 / 字号 / 行高 / 连字,与配色独立可配。
*
* 主题 key 必须与 Rust 侧 `NoteSettings.editorTheme` 的取值保持一致,
* 主题 key 必须与 Rust 侧 `EditorSettings.editorTheme` 的取值保持一致,
* 否则用户选了主题却静默回落默认(终端模块踩过这个坑)。
*/
import { EditorView } from '@codemirror/view'
@@ -29,6 +29,21 @@ interface ThemeDefinition {
extension: Extension
}
/**
* 给一套主题的 TagStyle 补上**元信息**配色(`<?xml ?>`、`<!DOCTYPE>`、注解等)。
*
* `t.meta` 及其子标签(`processingInstruction` / `documentMeta` / `annotation`)原先在
* 自建主题里没有任何规则,于是落到 `defaultHighlightStyle` 的兜底色 `#404740` —— 深色
* 主题下几乎与背景同色,表现为「文件开头的 `<?xml ... ?>` 没有高亮」。这里统一补上,
* 取各主题的**关键字色**(VS Code 也把 XML 声明 / DOCTYPE 归入 `#569cd6` 这一族)。
*
* 追加在数组末尾不会影响既有规则:CM6 的 HighlightStyle 中靠前的规则优先,
* 而 `meta` 现有规则本就没有匹配项。
*/
function withMeta(styles: TagStyle[], color: string): TagStyle[] {
return [...styles, { tag: t.meta, color }]
}
const VSCODE_DARK: TagStyle[] = [
{ tag: [t.comment, t.lineComment, t.blockComment], color: '#6a9955' },
{ tag: [t.keyword, t.controlKeyword, t.operatorKeyword, t.moduleKeyword], color: '#569cd6' },
@@ -200,7 +215,7 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
gutterActiveForeground: '#cccccc',
gutterBorder: '#00000000'
},
styles: VSCODE_DARK
styles: withMeta(VSCODE_DARK, '#569cd6')
})
},
'vscode-light': {
@@ -219,7 +234,7 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
gutterActiveForeground: '#0b216f',
gutterBorder: '#00000000'
},
styles: VSCODE_LIGHT
styles: withMeta(VSCODE_LIGHT, '#0000ff')
})
},
'one-dark': {
@@ -242,7 +257,7 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
gutterActiveForeground: '#f8f8f2',
gutterBorder: '#00000000'
},
styles: DRACULA
styles: withMeta(DRACULA, '#ff79c6')
})
},
'solarized-dark': {
@@ -261,7 +276,7 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
gutterActiveForeground: '#93a1a1',
gutterBorder: '#00000000'
},
styles: SOLARIZED_DARK
styles: withMeta(SOLARIZED_DARK, '#859900')
})
},
'solarized-light': {
@@ -280,7 +295,7 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
gutterActiveForeground: '#586e75',
gutterBorder: '#00000000'
},
styles: SOLARIZED_LIGHT
styles: withMeta(SOLARIZED_LIGHT, '#859900')
})
},
'jetbrains-darcula': {
@@ -299,7 +314,7 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
gutterActiveForeground: '#a1a3a5',
gutterBorder: '#00000000'
},
styles: JETBRAINS_DARCULA
styles: withMeta(JETBRAINS_DARCULA, '#cc7832')
})
},
'intellij-light': {
@@ -318,7 +333,7 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
gutterActiveForeground: '#666666',
gutterBorder: '#00000000'
},
styles: INTELLIJ_LIGHT
styles: withMeta(INTELLIJ_LIGHT, '#0033b3')
})
},
'monokai-pro': {
@@ -337,11 +352,39 @@ export const EDITOR_THEMES: Record<string, ThemeDefinition> = {
gutterActiveForeground: '#fcfcfa',
gutterBorder: '#00000000'
},
styles: MONOKAI_PRO
styles: withMeta(MONOKAI_PRO, '#ff6188')
})
}
}
/**
* 各主题(**实际生效名**)的编辑器底色。
*
* 用途:编辑器「外壳」容器(`.editor-host`)也要用同一底色 —— 否则 CM6 未绘制到的
* 区域(正文下方留白等)会透出窗口的 mica 背景,看起来「编辑器是透明的」。
*/
const THEME_BACKGROUNDS: Record<string, string> = {
'vscode-dark': '#1e1e1e',
'vscode-light': '#ffffff',
'one-dark': '#282c34',
dracula: '#282a36',
'solarized-dark': '#002b36',
'solarized-light': '#fdf6e3',
'jetbrains-darcula': '#2b2b2b',
'intellij-light': '#ffffff',
'monokai-pro': '#2d2a2e'
}
/** 求实际生效主题的编辑器底色(供编辑器外壳同步,避免窗口背景透出)。 */
export function editorBackground(
theme: string,
followAppTheme: boolean,
isDark: boolean
): string {
const name = effectiveThemeName(theme, followAppTheme, isDark)
return THEME_BACKGROUNDS[name] ?? THEME_BACKGROUNDS['vscode-dark']!
}
/** 设置页下拉选项(`system` 置于首位) */
export const EDITOR_THEME_OPTIONS: Array<{ value: string; label: string }> = [
{ value: 'system', label: '跟随应用' },
File renamed without changes.
+171
View File
@@ -0,0 +1,171 @@
/**
* 笔记模块的 IPC 客户端:命令名的**唯一落点**。
*
* # 为什么不直接在组件/ store 里写 `invoke('editor_xxx')`
*
* P0 阶段本项目还没有为新增命令重新生成 `src/lib/bindings.ts`(那需要一次
* debug 构建跑 `export_bindings`),于是新增命令的类型只能手写。手写类型散落在
* 十几处调用点时会同步腐坏:后端改个字段,前端在另一个文件里仍然编译通过。
* 因此这里做一层薄封装 —— **命令名与返回类型只在本文件出现一次**,
* 待 `bindings.ts` 重新生成后,改这一个文件即可完成切换。
*
* 参数名一律用 snake_case 形态的 camelCase(`relPath` / `dirRel` …),与
* tauri-specta 生成的调用约定一致;改错参数名会被 Tauri 在运行时报
* `invalid args`,所以这里刻意不做「参数对象透传」的花活,只做显式形参。
*/
import { invoke } from '@tauri-apps/api/core'
import type {
BackupReport,
BackupSnapshot,
ContextMenuStatus,
DeleteReport,
DirListing,
ImportReport,
LibraryEntry,
LibraryInfo,
LinkEdge,
NoteBacklinks,
NoteDoc,
NoteFileDoc,
NoteIndexReport,
NoteIndexStats,
EditorSettings,
OpenTargetPayload,
PathSearchQuery,
PathSearchResult,
PathReplaceQuery,
PathReplaceResult,
SyncOutcome,
TemplateSource,
WebdavStatus,
WebdavTestResult
} from '@/types/editor'
import type { NoteSearchHit, NoteTemplate } from '@/types/editor'
export const editorClient = {
// ===== 设置 =====
getSettings: () => invoke<EditorSettings>('editor_get_settings'),
saveSettings: (settings: EditorSettings) =>
invoke<EditorSettings>('editor_save_settings', { settings }),
// ===== 库 =====
libraryInfo: () => invoke<LibraryInfo>('editor_library_info'),
setLibraryRoot: (root: string | null) => invoke<LibraryInfo>('editor_set_library_root', { root }),
scanLibrary: () => invoke<LibraryEntry[]>('editor_scan_library'),
readNote: (relPath: string) => invoke<NoteDoc>('editor_read_note', { relPath }),
saveNote: (relPath: string, content: string) =>
invoke<NoteDoc>('editor_save_note', { relPath, content }),
/**
* 临时草稿文件的存放目录(`{app_data_dir}/editor/scratch`,不存在则创建)。
*
* 「新建临时文件」用它:目录里的文件**不随应用退出删除**,由「关闭该文件时选择
* 保存 / 删除」收尾(见 `EditorWindow` 的草稿关闭流程)。
*/
scratchDir: () => invoke<string>('editor_scratch_dir'),
createNote: (dirRel: string, name: string, templateId?: string) =>
invoke<NoteDoc>('editor_create_note', { dirRel, name, templateId: templateId ?? null }),
createFolder: (dirRel: string, name: string) =>
invoke<null>('editor_create_folder', { dirRel, name }),
renameEntry: (relPath: string, newName: string) =>
invoke<string>('editor_rename_entry', { relPath, newName }),
deleteEntry: (relPath: string) => invoke<null>('editor_delete_entry', { relPath }),
/** 打开(或创建)今天的日记 */
dailyNote: () => invoke<NoteDoc>('editor_daily_note'),
// ===== 索引与检索 =====
rebuildIndex: () => invoke<NoteIndexReport>('editor_rebuild_index'),
syncIndex: () => invoke<NoteIndexReport>('editor_sync_index'),
listNotes: (limit?: number) => invoke<NoteSearchHit[]>('editor_list_notes', { limit: limit ?? null }),
indexStats: () => invoke<NoteIndexStats>('editor_index_stats'),
/**
* 「在路径中查找」(Find in Path):对目录逐行做文本 / 正则检索。
*
* 与索引检索(`editor_search_notes`)解耦:这里直接扫盘,返回**行号 + 预览**,
* 支持正则 —— 统一搜索器的「当前目录 / 笔记库」两个范围走它。
*/
searchInPath: (query: PathSearchQuery) =>
invoke<PathSearchResult>('editor_search_in_path', { query }),
/**
* 「在路径中替换」(Replace in Path):把匹配结果**写回磁盘**。
*
* 破坏性操作,调用方必须先让用户确认。后端只处理合法 UTF-8 文件并保留 BOM / 换行,
* 非 UTF-8 与写入失败的文件会在 `skipped` 里逐个回报(不静默丢弃)。
*/
replaceInPath: (query: PathReplaceQuery) =>
invoke<PathReplaceResult>('editor_replace_in_path', { query }),
/** 一篇笔记的出链 / 入链 */
backlinks: (relPath: string) => invoke<NoteBacklinks>('editor_backlinks', { relPath }),
/** 全库链接图(已解析的内部链接边) */
linkGraph: () => invoke<LinkEdge[]>('editor_link_graph'),
/**
* 取出「启动时命令行 / 文件关联指定的文件」(取走即清空)。
*
* 冷启动时 Rust 无法 `emit`(前端还没注册监听),因此改为前端主动取一次。
*/
takePendingFile: () => invoke<OpenTargetPayload | null>('editor_take_pending_file'),
// ===== 库外任意文件 =====
openFile: (path: string) => invoke<NoteFileDoc>('editor_open_file', { path }),
/** 以指定编码重新解码磁盘字节(切换编码用;不写回) */
redecodeFile: (path: string, encoding: string) =>
invoke<NoteFileDoc>('editor_redecode_file', { path, encoding }),
writeFile: (path: string, content: string, encoding: string, eol: string) =>
invoke<NoteFileDoc>('editor_write_file', { path, content, encoding, eol }),
/** 登记系统对话框选中的路径为「可写」(它不是经 `openFile` 打开的) */
authorizeFile: (path: string) => invoke<null>('editor_authorize_file', { path }),
/** 把 base64 图片写进库根 `assets/`,返回可插入 Markdown 的相对路径 */
writeAsset: (fileName: string, ext: string, dataBase64: string) =>
invoke<string>('editor_write_asset', { fileName, ext, dataBase64 }),
/**
* 把库内图片读成 `data:` URL(内联预览用)。
*
* 返回 `null` 表示「不适合预览」(非图片扩展名 / 超过大小上限)——
* 不是错误,调用方按普通文本渲染即可。
*/
readAsset: (relPath: string) => invoke<string | null>('editor_read_asset', { relPath }),
// ===== 模板(P2) =====
listTemplates: () => invoke<NoteTemplate[]>('editor_list_templates'),
/** 不带参数 = 把全部内置模板导出到库内 `templates/` */
addTemplate: (name?: string, body?: string) =>
invoke<string[]>('editor_add_template', { name: name ?? null, body: body ?? null }),
readTemplate: (templateId: string) =>
invoke<TemplateSource>('editor_read_template', { templateId }),
// ===== 导入 / 导出(P2) =====
import: (source: string, destDir: string) =>
invoke<ImportReport>('editor_import', { source, destDir }),
/** 把渲染好的 HTML 写到用户选定的位置(渲染在前端,落盘在后端) */
exportNote: (relPath: string, html: string, dest: string) =>
invoke<string>('editor_export_note', { relPath, html, dest }),
exportZip: (dest: string, dirRel?: string) =>
invoke<string>('editor_export_zip', { dest, dirRel: dirRel ?? null }),
exportSnapshotLocal: (dest?: string) =>
invoke<string>('editor_export_snapshot_local', { dest: dest ?? null }),
// ===== WebDAV(P2) =====
webdavStatus: () => invoke<WebdavStatus>('editor_webdav_status'),
setWebdavPassword: (password: string) =>
invoke<null>('editor_set_webdav_password', { password }),
testWebdav: () => invoke<WebdavTestResult>('editor_test_webdav'),
syncNow: () => invoke<SyncOutcome>('editor_sync_now'),
backupNow: () => invoke<BackupReport>('editor_backup_now'),
listBackups: () => invoke<BackupSnapshot[]>('editor_list_backups'),
restoreBackup: (name: string) => invoke<ImportReport>('editor_restore_backup', { name }),
// ===== 本地目录(P3-5,操作用户真实文件系统) =====
readDir: (path: string) => invoke<DirListing>('editor_read_dir', { path }),
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) =>
invoke<string>('editor_rename_path', { path, newName }),
/** 移动到目标目录下 */
movePath: (path: string, destDir: string) =>
invoke<string>('editor_move_path', { path, destDir }),
deletePath: (paths: string[]) => invoke<DeleteReport>('editor_delete_path', { paths }),
// ===== 系统集成(P4-4,HKCU 右键菜单) =====
contextMenuStatus: () => invoke<ContextMenuStatus>('editor_context_menu_status'),
registerContextMenu: () => invoke<ContextMenuStatus>('editor_register_context_menu'),
unregisterContextMenu: () => invoke<ContextMenuStatus>('editor_unregister_context_menu')
}
+46
View File
@@ -0,0 +1,46 @@
import type { ModuleConfig } from '@/types/module'
import type { SearchIndexItem } from '@/stores/searchIndex'
/**
* 全局搜索索引(本模块无内部 Tab,`tab` 一律省略 —— 搜索后直接落在模块页)。
*/
const searchItems: SearchIndexItem[] = [
{
title: '编辑器',
description: '通用文本 / 代码编辑器:Markdown 实时预览、多编码、本地目录与笔记库',
keywords: ['编辑器', 'editor', 'notepad', '文本', '代码', 'markdown', 'md', '笔记', 'notes']
},
{
title: '打开编辑器',
description: '在新窗口中打开文件 / 笔记(可多开)',
keywords: ['打开', '编辑器', '窗口', '独立窗口', 'editor', '文件', '打开文件']
},
{
title: '打开文件夹',
description: '在编辑器的本地目录面板中打开一个文件夹',
keywords: ['打开', '文件夹', '目录', '目录树', 'folder', 'directory']
},
{
title: '新建笔记',
description: '在笔记库中新建一篇 Markdown 笔记',
keywords: ['新建', '新建笔记', 'new', '创建', 'create']
},
{
title: '编辑器设置',
description: '库根目录、编辑器主题、字体字号、编码、自动保存',
keywords: ['设置', '主题', '字体', '字号', '库目录', '库根', '编码', '自动保存', 'vscode', 'darcula']
}
]
export const moduleConfig: ModuleConfig = {
id: 'editor',
name: '编辑器',
icon: 'editor',
description: '通用文本 / 代码编辑器(Markdown 实时预览 + 多语言高亮 + 本地目录 + 笔记库)',
category: 'tool',
defaultEnabled: true,
loader: () => import('./EditorModule.vue'),
searchItems,
// 默认排在终端(40)之后
order: 45
}
@@ -1,15 +1,15 @@
/**
* 笔记「独立窗口」的创建入口(由前端创建,范式同 terminal/openWindow.ts)。
*
* - label 前缀 `notes-window-` 命中 `capabilities/notes-window.json` 的 `notes-window-*` 授权;
* - label 前缀 `editor-window-` 命中 `capabilities/editor-window.json` 的 `editor-window-*` 授权;
* - **隐藏创建**:窗口初始底色是白的,而主题要等前端读 localStorage 后才应用 ——
* 直接显示会先闪一下纯白。由 NotesWindow.vue 应用完主题(含窗口效果)再自己 show;
* 直接显示会先闪一下纯白。由 EditorWindow.vue 应用完主题(含窗口效果)再自己 show;
* - **同目标判重聚焦**(规划 §8-Q1 选 (a)):窗口默认多开,但「同一个文件开两个窗口」
* 几乎总是误操作 —— 两个窗口各自自动保存,后写的会覆盖先写的。
*
* # label 里为什么是哈希而不是明文路径
*
* 判重需要「由目标反推出窗口 label」。用 `notes-window-<目标>` 最直观,但窗口 label
* 判重需要「由目标反推出窗口 label」。用 `editor-window-<目标>` 最直观,但窗口 label
* 会出现在系统任务栏与调试面板里,把绝对路径(含用户名、项目名)塞进去既不雅也
* 不必要。改用 FNV-1a 哈希:**同样稳定、可反推 label、但不泄露路径**。
* 哈希碰撞的后果只是「两个不同文件被当成同一个窗口」——32 位空间下这在单次会话里
@@ -18,12 +18,12 @@
import { WebviewWindow } from '@tauri-apps/api/webviewWindow'
import { createLogger } from '@/lib/logger'
import { WINDOWS } from '@/lib/constants'
import { useNotesStore } from '@/stores/notesStore'
import { useEditorStore } from '@/stores/editorStore'
const logger = createLogger('notes')
const logger = createLogger('editor')
/** label 前缀必须落在 `notes-window-*`(capability 的 glob)里 */
const LABEL_PREFIX = `${WINDOWS.notesWindow}-`
/** label 前缀必须落在 `editor-window-*`(capability 的 glob)里 */
const LABEL_PREFIX = `${WINDOWS.editorWindow}-`
/** FNV-1a 32 位哈希 → base36(稳定、短、无特殊字符)。 */
function hashTarget(target: string): string {
@@ -54,27 +54,32 @@ async function focusTarget(target: string): Promise<boolean> {
}
/**
* 打开一个笔记窗口。
* 打开一个编辑器窗口。
*
* @param options.relPath 可选:打开时直达的笔记(相对库根路径)
* @param options.path 可选:打开时直达的**库外文件**(绝对路径,供 P1 的「打开文件」用)
* @param options.path 可选:打开时直达的**库外文件**(绝对路径)
* @param options.folder 可选:打开时直达的**本地目录**(绝对路径,目录面板)
* @param options.dedupe 同一目标已开窗口时聚焦它(默认 true)
*/
export async function openNotesWindow(options?: {
export async function openEditorWindow(options?: {
relPath?: string
path?: string
folder?: string
dedupe?: boolean
}): Promise<void> {
const isFile = !options?.relPath && !!options?.path
const target = options?.relPath ?? options?.path ?? ''
const query = target
? `?${isFile ? 'path' : 'file'}=${encodeURIComponent(target)}`
: ''
const target = options?.relPath ?? options?.path ?? options?.folder ?? ''
const query = options?.relPath
? `?file=${encodeURIComponent(options.relPath)}`
: options?.path
? `?path=${encodeURIComponent(options.path)}`
: options?.folder
? `?folder=${encodeURIComponent(options.folder)}`
: ''
if (target && options?.dedupe !== false) {
// 「复用文档窗口」是可关闭的设置(默认开)。关掉时每次新建窗口 ——
// 有些用户确实想并排对照同一篇的不同位置。
const reuse = useNotesStore().settings.reuseWindow
const reuse = useEditorStore().settings.reuseWindow
if (reuse) {
const focused = await focusTarget(target)
if (focused) return
@@ -88,8 +93,8 @@ export async function openNotesWindow(options?: {
const finalLabel = taken ? `${label}-${Date.now().toString(36)}` : label
const win = new WebviewWindow(finalLabel, {
url: `index.html#${WINDOWS.notesWindow}${query}`,
title: '笔记',
url: `index.html#${WINDOWS.editorWindow}${query}`,
title: '编辑器',
width: 1200,
height: 800,
minWidth: 760,
@@ -105,7 +110,7 @@ export async function openNotesWindow(options?: {
})
win.once('tauri://error', e => {
logger.error(`打开笔记窗口失败:${String(e)}`)
logger.error(`打开编辑器窗口失败:${String(e)}`)
})
await new Promise<void>((resolve, reject) => {
+2 -2
View File
@@ -12,7 +12,7 @@ import {
Languages,
SquareTerminal,
Bot,
NotebookPen
FileCode2
} from '@lucide/vue'
/**
@@ -35,7 +35,7 @@ export const moduleIconMap: Record<string, Component> = {
translate: Languages,
terminal: SquareTerminal,
dsh: Bot,
notes: NotebookPen
editor: FileCode2
}
/** 获取模块图标组件,未找到时回退到 Settings 图标 */
+2 -2
View File
@@ -14,7 +14,7 @@ import { moduleConfig as music } from './music'
import { moduleConfig as translate } from './translate'
import { moduleConfig as terminal } from './terminal'
import { moduleConfig as dsh } from './dsh'
import { moduleConfig as notes } from './notes'
import { moduleConfig as editor } from './editor'
const allModules: ModuleConfig[] = [
proxy,
@@ -29,7 +29,7 @@ const allModules: ModuleConfig[] = [
translate,
terminal,
dsh,
notes
editor
]
// 启动时注册所有模块
-525
View File
@@ -1,525 +0,0 @@
<script setup lang="ts">
/**
* 笔记独立窗口根组件(`#notes-window`)。
*
* # 为什么是独立窗口
*
* 主模块页只做设置与管理;真正的编辑发生在这里 —— 可多开、可拖到副屏,
* 编辑体验接近一个独立应用(与终端 / 下载 / 翻译窗口同一范式)。
*
* # 生命周期要点
*
* - 窗口由 `openWindow.ts` **隐藏创建**,本组件 `applyTheme` 之后才 `show`
* (否则深色模式下会先闪一下纯白窗口);
* - 自带一份 Pinia(`main.ts` 里为独立窗口注入),store 通过 IPC 与 Rust 对齐;
* - 监听 `notes-settings` / `notes-library-changed` / `notes-file-changed`
* 实现与主窗口及外部编辑器的实时同步。
*
* # P1 新增的三种「异步危险」
*
* 1. **外部改动**:库文件在别的编辑器里被改了,而我们这边有未保存内容 —— 不能
* 静默重载(会丢掉用户刚敲的字),弹出横幅让用户选;
* 2. **打开库外文件**:路径来自系统对话框,必须先 `authorize` 才能写回;
* 3. **大文件**:超过阈值时关掉 Live Preview / 折叠 / 补全(降级在 `core.ts`,
* 这里只负责把 `large` 标记和提示露出来)。
*/
import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
import { Effect, EffectState, getCurrentWindow } from '@tauri-apps/api/window'
import { open } from '@tauri-apps/plugin-dialog'
import { AlertTriangle, Minus, NotebookPen, PanelLeft, Square, X } from '@lucide/vue'
import { toast } from 'vue-sonner'
import { Toaster } from '@/components/ui/sonner'
import { Button } from '@/components/ui/button'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
import { ConfirmDialog, StateBlock } from '@/components/common'
import { STORAGE_KEYS } from '@/lib/constants'
import { applyStoredAccent } from '@/lib/theme'
import { createLogger } from '@/lib/logger'
import { useNotesStore } from '@/stores/notesStore'
import LibrarySidebar from './components/LibrarySidebar.vue'
import EditorHost from './components/EditorHost.vue'
import EditorToolbar from './components/EditorToolbar.vue'
import QuickOpen from './components/QuickOpen.vue'
import type { NoteViewMode } from '@/types/notes'
import type { Command, EditorView } from '@codemirror/view'
const logger = createLogger('notes')
const win = getCurrentWindow()
const store = useNotesStore()
const isDark = ref(false)
const sidebarVisible = ref(true)
const viewMode = ref<NoteViewMode>('wysiwyg')
const hostRef = ref<InstanceType<typeof EditorHost> | null>(null)
const sidebarRef = ref<InstanceType<typeof LibrarySidebar> | null>(null)
const quickOpen = ref(false)
const cursorLine = ref(0)
const cursorColumn = ref(1)
// ===== 主题与窗口效果(与主应用同步) =====
function readMainTheme(): { theme: string; effect: string } {
try {
const raw = localStorage.getItem(STORAGE_KEYS.appSettings)
if (raw) {
const s = JSON.parse(raw) as { theme?: string; effect?: string }
return { theme: s.theme ?? 'system', effect: s.effect ?? 'mica' }
}
} catch {
/* 设置不可读时按默认处理 */
}
return { theme: 'system', effect: 'mica' }
}
function resolveIsDark(theme: string): boolean {
if (theme === 'dark') return true
if (theme === 'light') return false
return window.matchMedia('(prefers-color-scheme: dark)').matches
}
async function applyTheme(): Promise<void> {
const root = document.documentElement
const { theme, effect } = readMainTheme()
try {
await win.setTheme(theme === 'system' ? null : (theme 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}`)
if (dark) root.classList.add('dark')
applyStoredAccent(root, dark ? 'dark' : 'light', STORAGE_KEYS.appSettings)
try {
// setEffects 会直接覆盖当前效果,无需 clearEffects(那个命令未在 capability 中授权)
if (effect === 'mica') {
await win.setEffects({
effects: [Effect.Mica],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
await win.setBackgroundColor('#00000000')
root.style.setProperty('--popup-bg', 'transparent')
} else if (effect === 'acrylic') {
await win.setEffects({
effects: [Effect.Acrylic],
state: EffectState.FollowsWindowActiveState,
color: dark ? [30, 41, 59, 0] : [248, 250, 252, 0]
})
await win.setBackgroundColor('#00000000')
root.style.setProperty('--popup-bg', 'transparent')
} else {
const bg = dark ? '#16161a' : '#ffffff'
await win.setBackgroundColor(bg)
root.style.setProperty('--popup-bg', bg)
}
} catch {
/* 忽略效果设置失败 */
}
}
const darkMedia = window.matchMedia('(prefers-color-scheme: dark)')
const onThemeChange = () => void applyTheme()
const onStorageChange = (e: StorageEvent) => {
if (e.key === STORAGE_KEYS.appSettings) void applyTheme()
}
// ===== 窗口控制 =====
const doMinimize = () => win.minimize().catch(() => undefined)
const doToggleMaximize = () => win.toggleMaximize().catch(() => undefined)
/** 关闭确认(有未保存改动时) */
const closeConfirmOpen = ref(false)
async function doClose(): Promise<void> {
if (store.dirty) {
closeConfirmOpen.value = true
return
}
await forceClose()
}
async function forceClose(): Promise<void> {
try {
await store.saveCurrent()
} catch {
/* 保存失败不阻塞关闭;脏数据仍在编辑器里 */
}
win.close().catch(() => undefined)
}
const startDrag = () => {
win.startDragging().catch(() => undefined)
}
// ===== 编辑器命令转发 =====
function applyCommand(command: Command): void {
const view = hostRef.value?.getView() as EditorView | null | undefined
if (view) command(view)
}
async function doSave(): Promise<void> {
try {
await store.saveCurrent()
toast.success('已保存')
} catch (e) {
toast.error(`保存失败:${String(e)}`)
}
}
function onCursorMoved(line: number, column: number): void {
cursorLine.value = line
cursorColumn.value = column
sidebarRef.value?.setCursorLine(line)
}
/**
* 点击 `[[wikilink]]`。
*
* 目标是**库内相对路径**(`名字.md`)—— 与 Rust 侧 `resolve_link` 的「按名字 + 相对
* 当前目录」判据保持一致。找不到就按这个名字在当前笔记所在目录新建一篇:
* 「先写链接、后补内容」是双链笔记的标准用法,静默失败会让这个习惯立刻失效。
*/
async function onWikilink(target: string): Promise<void> {
const name = target.trim()
if (!name) return
const dir = store.currentRelPath.split('/').slice(0, -1).join('/')
const relPath = dir ? `${dir}/${name}.md` : `${name}.md`
if (store.entries.some(entry => entry.relPath === relPath)) {
await store.openNote(relPath)
return
}
try {
await store.createNote(dir, name)
toast.success(`已新建「${name}」`)
} catch (e) {
toast.error(`新建失败:${String(e)}`)
}
}
// ===== 打开库外文件 =====
async function doOpenFile(): Promise<void> {
try {
const selected = await open({
multiple: false,
directory: false,
title: '打开文件',
filters: [
{ name: '文本 / 代码', extensions: ['md', 'txt', 'json', 'yaml', 'yml', 'toml', 'ini', 'log', 'csv'] },
{ name: '全部文件', extensions: ['*'] }
]
})
if (typeof selected !== 'string') return
await store.openFile(selected)
} catch (e) {
toast.error(`打开文件失败:${String(e)}`)
}
}
// ===== 外部改动 =====
const externalConfirmOpen = ref(false)
async function reloadFromExternal(): Promise<void> {
try {
await store.reloadCurrent()
store.externalChange = null
toast.success('已重新载入')
} catch (e) {
toast.error(`重新载入失败:${String(e)}`)
} finally {
externalConfirmOpen.value = false
}
}
/** 「保留我的改动」:只清掉提示,磁盘上的版本仍是外部那份(用户下次保存会覆盖它) */
function keepLocal(): void {
store.externalChange = null
externalConfirmOpen.value = false
}
// ===== 全局按键(窗口级) =====
function onKeydown(event: KeyboardEvent): void {
const mod = event.ctrlKey || event.metaKey
if (!mod) return
const key = event.key.toLowerCase()
if (key === 's') {
event.preventDefault()
void doSave()
} else if (key === 'p' && !event.shiftKey) {
event.preventDefault()
quickOpen.value = true
} else if (key === 'o') {
event.preventDefault()
void doOpenFile()
} else if (key === 'f' && event.shiftKey) {
event.preventDefault()
sidebarVisible.value = true
sidebarRef.value?.showSearch()
} else if (key === 'm' && event.shiftKey) {
event.preventDefault()
viewMode.value = viewMode.value === 'wysiwyg' ? 'source' : 'wysiwyg'
} else if (key === 'l' && event.shiftKey) {
event.preventDefault()
sidebarVisible.value = true
sidebarRef.value?.showOutline()
} else if (key === 'n' && event.shiftKey) {
// 与全局快捷键同义:窗口内有焦点时在本窗口直接开对话框,不必绕 Rust 一圈
event.preventDefault()
sidebarVisible.value = true
sidebarRef.value?.showNewNote()
}
}
/** 从 hash 查询串解析初始要打开的文档(`file` = 库内笔记,`path` = 库外文件)。 */
function initialTarget(): { relPath: string; path: string } {
const hash = window.location.hash
const queryIndex = hash.indexOf('?')
if (queryIndex < 0) return { relPath: '', path: '' }
const params = new URLSearchParams(hash.slice(queryIndex + 1))
return { relPath: params.get('file') ?? '', path: params.get('path') ?? '' }
}
onMounted(async () => {
darkMedia.addEventListener('change', onThemeChange)
window.addEventListener('storage', onStorageChange)
window.addEventListener('keydown', onKeydown, true)
// 主题 → 显示(窗口是隐藏创建的,这一步之后用户才第一次看到它)
await applyTheme()
try {
await win.show()
await win.setFocus()
} catch (e) {
logger.warn(`显示笔记窗口失败:${String(e)}`)
}
await store.init()
viewMode.value = store.settings.defaultView === 'source' ? 'source' : 'wysiwyg'
const { relPath: targetRel, path: targetPath } = initialTarget()
if (targetRel) {
await store.openNote(targetRel)
} else if (targetPath) {
try {
await store.openFile(targetPath)
} catch (e) {
toast.error(`打开文件失败:${String(e)}`)
}
} else if (store.recent.length) {
await store.openNote(store.recent[0].relPath)
}
})
onBeforeUnmount(() => {
darkMedia.removeEventListener('change', onThemeChange)
window.removeEventListener('storage', onStorageChange)
window.removeEventListener('keydown', onKeydown, true)
store.disposeListeners()
})
// ===== 状态栏 =====
const title = computed(() => store.currentName || '笔记')
const statusText = computed(() => {
if (store.saving) return '保存中…'
if (store.dirty) return '未保存'
if (!store.hasDocument) return '未打开文档'
return '已保存'
})
/** 编码 / 换行只在库外文件里有意义(笔记永远是 UTF-8 + 换行跟随原文) */
const encodingLabel = computed(() => (store.kind === 'file' ? store.fileDoc?.encoding ?? '' : ''))
const eolLabel = computed(() => {
if (store.kind !== 'file') return ''
return store.fileDoc?.eol === 'crlf' ? 'CRLF' : 'LF'
})
</script>
<template>
<div class="notes-window flex h-screen flex-col overflow-hidden text-foreground">
<!-- 自绘标题栏:仅标题区是拖动区,右侧按钮区不是(否则鼠标事件被拖动拦截) -->
<header class="flex h-9 shrink-0 items-center gap-1 border-b border-border px-2">
<div
class="flex h-full min-w-0 flex-1 items-center gap-2 pl-1"
data-tauri-drag-region
@mousedown="startDrag"
>
<NotebookPen class="size-3.5 shrink-0 text-primary" />
<span class="pointer-events-none truncate text-xs font-medium">{{ title }}</span>
<span
v-if="store.kind === 'file'"
class="pointer-events-none shrink-0 rounded-sm bg-muted px-1 text-[10px] text-fg-secondary"
>
文件
</span>
<span v-if="store.dirty" class="size-1.5 shrink-0 rounded-full bg-primary" />
</div>
<div class="w-px h-4 bg-border shrink-0" />
<TooltipProvider :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="sidebarVisible = !sidebarVisible">
<PanelLeft class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">切换侧栏</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="doMinimize">
<Minus class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">最小化</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button variant="ghost" size="icon-sm" @click="doToggleMaximize">
<Square class="size-3" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">最大化 / 还原</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger as-child>
<Button
variant="ghost"
size="icon-sm"
class="hover:!bg-destructive hover:!text-destructive-foreground"
@click="doClose"
>
<X class="size-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">关闭窗口</TooltipContent>
</Tooltip>
</TooltipProvider>
</header>
<!-- 工具栏 -->
<EditorToolbar
:apply="applyCommand"
:view-mode="viewMode"
:dirty="store.dirty"
:saving="store.saving"
:name="store.currentName"
@update:view-mode="viewMode = $event"
@save="doSave"
@open-file="doOpenFile"
@quick-open="quickOpen = true"
/>
<!-- 外部改动提示(有未保存改动时才会出现) -->
<div
v-if="store.externalChange"
class="flex shrink-0 items-center gap-2 border-b border-border bg-warning-soft px-3 py-1.5 text-xs"
>
<AlertTriangle class="size-3.5 shrink-0 text-warning" />
<span class="min-w-0 flex-1 truncate">
该文件已在应用外被
{{ store.externalChange.kind === 'removed' ? '删除' : '修改' }}
—— 你的未保存改动仍在编辑器里
</span>
<Button variant="outline" size="sm" @click="keepLocal">保留我的改动</Button>
<Button variant="outline" size="sm" @click="externalConfirmOpen = true">查看并重载</Button>
</div>
<!-- 大文件降级提示 -->
<div
v-if="store.fileDoc?.large"
class="flex shrink-0 items-center gap-2 border-b border-border bg-muted px-3 py-1 text-[11px] text-muted-foreground"
>
<AlertTriangle class="size-3 shrink-0" />
文件较大,已关闭「所见即所得 / 折叠 / 自动补全」以保证输入流畅
</div>
<!-- 主体:侧栏 + 编辑器 -->
<div class="flex min-h-0 flex-1">
<LibrarySidebar
v-if="sidebarVisible"
ref="sidebarRef"
@open="store.openNote($event)"
@jump="hostRef?.jumpTo($event)"
/>
<main class="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"
title="未打开文档"
description="从左侧选择一篇笔记、新建一篇,或用 Ctrl+O 打开磁盘上的文件"
:min-height="200"
>
<template #action>
<div class="flex gap-2">
<Button variant="outline" size="sm" @click="sidebarVisible = true">
<PanelLeft class="size-3.5" />打开侧栏
</Button>
<Button variant="outline" size="sm" @click="doOpenFile">打开文件…</Button>
</div>
</template>
</StateBlock>
</div>
<EditorHost
v-show="store.hasDocument"
ref="hostRef"
:is-dark="isDark"
:live-preview="viewMode === 'wysiwyg'"
@cursor-moved="onCursorMoved"
@wikilink="onWikilink"
/>
</main>
</div>
<!-- 状态栏 -->
<footer
class="flex h-7 shrink-0 items-center gap-3 border-t border-border px-3 text-[11px] text-muted-foreground"
>
<span>{{ statusText }}</span>
<span v-if="store.hasDocument" class="tabular-nums">
{{ store.wordCount }} 字 · {{ store.lineCount }} 行
</span>
<span v-if="store.hasDocument" class="tabular-nums">行 {{ cursorLine }} : {{ cursorColumn }}</span>
<span v-if="store.kind === 'note'" class="rounded-sm bg-muted px-1.5 py-0.5 text-[10px]">
{{ store.languageLabel }}
</span>
<span v-if="encodingLabel" class="uppercase">{{ encodingLabel }}</span>
<span v-if="eolLabel">{{ eolLabel }}</span>
<span class="ml-auto truncate">{{ store.fileDoc?.path || store.libraryRoot }}</span>
</footer>
<!-- 快速打开(Ctrl+P) -->
<QuickOpen v-model:open="quickOpen" @select="store.openNote($event)" />
<!-- 关闭确认 -->
<ConfirmDialog
v-model:open="closeConfirmOpen"
title="有未保存的改动"
description="关闭窗口会丢失这些改动(自动保存会对未保存内容做最后一次尝试)。"
confirm-text="保存并关闭"
@confirm="forceClose"
/>
<!-- 重载确认 -->
<ConfirmDialog
v-model:open="externalConfirmOpen"
title="重新载入将丢弃未保存的改动"
description="磁盘上的版本会覆盖编辑器里的内容,你当前的改动无法恢复。"
variant="danger"
confirm-text="丢弃并重载"
@confirm="reloadFromExternal"
/>
<Toaster />
</div>
</template>
<style scoped>
/* 窗口根容器:mica/acrylic 下透明,普通模式用不透明底色(--popup-bg 由 applyTheme 写入) */
.notes-window {
background: var(--popup-bg, var(--background));
}
</style>
@@ -1,243 +0,0 @@
<script setup lang="ts">
/**
* 编辑器工具栏:格式化按钮 + 视图切换 + 保存 + 配色快切 + 打开文件。
*
* 格式化命令通过 `apply` 由父级(NotesWindow)转发到当前 EditorView ——
* 工具栏本身不持有编辑器实例(实例在 EditorHost 内部,非响应式)。
*
* 控件尺寸与图标写法对齐项目约定:按钮图标显式 `size-3.5`、下拉用 `Select`。
*
* # 文件模式下藏掉 Markdown 格式按钮
*
* `.py` 文件里的「加粗 / 引用 / 任务列表」没有任何意义,留着只会让人以为按了
* 会有用。因此按 `store.kind` 切换:笔记显示格式化组,文件显示「打开 / 快速打开 /
* 编码与换行信息」,两者共用保存与配色。
*/
import {
Bold,
Code,
Eye,
FileDown,
FileSearch,
FolderOpen,
Heading1,
Heading2,
Heading3,
Italic,
Link,
List,
ListChecks,
Loader2,
Quote,
Save,
SquareCode,
Strikethrough
} from '@lucide/vue'
import { ref } from 'vue'
import { open } from '@tauri-apps/plugin-dialog'
import { toast } from 'vue-sonner'
import type { Command } from '@codemirror/view'
import { Button } from '@/components/ui/button'
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue
} from '@/components/ui/select'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
import { useNotesStore } from '@/stores/notesStore'
import { notesClient } from '../notesClient'
import { notesCommands } from '../editor/keymap'
import { EDITOR_THEME_OPTIONS } from '../editor/themes'
import type { NoteViewMode } from '@/types/notes'
const props = defineProps<{
apply: (command: Command) => void
viewMode: NoteViewMode
dirty: boolean
saving: boolean
name: string
}>()
const emit = defineEmits<{
'update:viewMode': [value: NoteViewMode]
save: []
'open-file': []
'quick-open': []
}>()
const store = useNotesStore()
const run = (command: Command) => props.apply(command)
const exporting = ref(false)
/**
* 导出当前笔记为 HTML。
*
* 渲染链路(markdown-it + DOMPurify + highlight.js)**按需 import**:
* 它约 1MB,而导出是低频动作 —— 静态引入会让「打开编辑器窗口」这个最常见的动作
* 也背上这份体积。
*/
async function exportHtml(): Promise<void> {
if (!store.currentRelPath) return
exporting.value = true
try {
const doc = await notesClient.readNote(store.currentRelPath)
const { renderNoteHtml } = await import('../editor/markdownExport')
const html = renderNoteHtml({
title: store.currentName || doc.name.replace(/\.md$/i, ''),
fileName: doc.name,
markdown: doc.content,
highlight: store.settings.exportHighlight
})
const dest = await open({
title: '导出为 HTML',
defaultPath: `${doc.name.replace(/\.md$/i, '')}.html`,
filters: [{ name: 'HTML 文件', extensions: ['html'] }]
})
if (typeof dest !== 'string') return
const saved = await notesClient.exportNote(store.currentRelPath, html, dest)
toast.success(`已导出:${saved}`)
} catch (e) {
toast.error(`导出失败:${String(e)}`)
} finally {
exporting.value = false
}
}
</script>
<template>
<div class="flex h-11 shrink-0 items-center gap-1 border-b border-border px-3">
<!-- 文档名 + 未保存标记 -->
<div class="mr-2 flex min-w-0 items-center gap-1.5">
<span class="truncate text-[13px] font-medium text-foreground">
{{ name || '未打开文档' }}
</span>
<span
v-if="dirty"
class="size-1.5 shrink-0 rounded-full bg-primary"
title="有未保存的改动"
/>
</div>
<div class="h-4 w-px shrink-0 bg-divider" />
<!-- ===== 笔记模式:Markdown 格式化 ===== -->
<template v-if="store.kind === 'note'">
<Button variant="ghost" size="icon-sm" title="加粗 (Ctrl+B)" @click="run(notesCommands.bold)">
<Bold class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="斜体 (Ctrl+I)" @click="run(notesCommands.italic)">
<Italic class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="删除线 (Ctrl+Shift+X)"
@click="run(notesCommands.strikethrough)"
>
<Strikethrough class="size-3.5" />
</Button>
<Button
variant="ghost"
size="icon-sm"
title="行内代码 (Ctrl+E)"
@click="run(notesCommands.inlineCode)"
>
<Code class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="链接 (Ctrl+K)" @click="run(notesCommands.link)">
<Link class="size-3.5" />
</Button>
<div class="h-4 w-px shrink-0 bg-divider" />
<Button variant="ghost" size="icon-sm" title="一级标题 (Ctrl+1)" @click="run(notesCommands.heading(1))">
<Heading1 class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="二级标题 (Ctrl+2)" @click="run(notesCommands.heading(2))">
<Heading2 class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="三级标题 (Ctrl+3)" @click="run(notesCommands.heading(3))">
<Heading3 class="size-3.5" />
</Button>
<div class="h-4 w-px shrink-0 bg-divider" />
<Button variant="ghost" size="icon-sm" title="无序列表" @click="run(notesCommands.bulletList)">
<List class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="任务列表" @click="run(notesCommands.taskList)">
<ListChecks class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="引用" @click="run(notesCommands.quote)">
<Quote class="size-3.5" />
</Button>
<Button variant="ghost" size="icon-sm" title="代码块 (Ctrl+Shift+C)" @click="run(notesCommands.codeBlock)">
<SquareCode class="size-3.5" />
</Button>
</template>
<!-- ===== 文件模式 ===== -->
<template v-else>
<Button variant="ghost" size="sm" title="打开磁盘文件 (Ctrl+O)" @click="emit('open-file')">
<FolderOpen class="size-3.5" />打开
</Button>
<Button variant="ghost" size="sm" title="快速打开 (Ctrl+P)" @click="emit('quick-open')">
<FileSearch class="size-3.5" />快速打开
</Button>
</template>
<div class="ml-auto flex shrink-0 items-center gap-2">
<!-- 导出当前笔记为 HTML(低频动作:渲染链路按需加载) -->
<Button
v-if="store.kind === 'note' && store.currentRelPath"
variant="ghost"
size="sm"
:disabled="exporting"
title="导出为独立 HTML(可离线打开或系统打印成 PDF)"
@click="exportHtml"
>
<Loader2 v-if="exporting" class="size-3.5 animate-spin" />
<FileDown v-else class="size-3.5" />
导出
</Button>
<!-- 配色快切(与设置页同一份取值) -->
<Select
:model-value="String(store.settings.editorTheme)"
@update:model-value="v => store.patchSettings({ editorTheme: String(v) })"
>
<SelectTrigger class="h-7 w-40 text-xs"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem v-for="opt in EDITOR_THEME_OPTIONS" :key="opt.value" :value="opt.value">
{{ opt.label }}
</SelectItem>
</SelectContent>
</Select>
<!-- 视图切换(只对 Markdown 有意义) -->
<TooltipProvider v-if="store.kind === 'note'" :delay-duration="400">
<Tooltip>
<TooltipTrigger as-child>
<Button
variant="ghost"
size="sm"
@click="emit('update:viewMode', viewMode === 'wysiwyg' ? 'source' : 'wysiwyg')"
>
<Eye class="size-3.5" />
{{ viewMode === 'wysiwyg' ? '所见即所得' : '源码' }}
</Button>
</TooltipTrigger>
<TooltipContent side="bottom">切换视图 (Ctrl+Shift+M)</TooltipContent>
</Tooltip>
</TooltipProvider>
<Button variant="outline" size="sm" :disabled="!dirty || saving" @click="emit('save')">
<Save class="size-3.5" />
保存
</Button>
</div>
</div>
</template>
@@ -1,173 +0,0 @@
<script setup lang="ts">
/**
* 库内全文检索面板(FTS5)。
*
* # 检索由 Rust 做,前端只做「输入 → 查询 → 渲染」
*
* 匹配、排序(标题权重高于正文)、片段提取、分页全部在 SQL 里完成:把候选集拉回
* 前端再过滤会在大库上卡住主线程,而且「命中总数」会变成假的(前端只拿到了当页)。
* 这里的防抖只是**省请求**,不是正确性的一部分。
*
* # 高亮片段为什么不用 v-html
*
* 片段来自用户笔记正文,直接 `v-html` 就是一个自找的 XSS 面。Rust 侧回传的是
* 用 `\u0002` / `\u0003` 定界的纯文本,这里切成数组后用 `<mark>` 渲染
* (见 `splitHighlight`)—— 文本永远走插值,不经过 HTML 解析。
*/
import { computed, onMounted, ref, watch } from 'vue'
import { FileText, Loader2, Search, Tag, X } from '@lucide/vue'
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 { useNotesStore } from '@/stores/notesStore'
import { splitHighlight } from '@/types/notes'
const emit = defineEmits<{ open: [relPath: string] }>()
const store = useNotesStore()
/** 输入框的值与「已提交的关键词」分开:前者每次按键都变,后者只在防抖后提交 */
const input = ref(store.searchKeyword)
const activeTag = ref(store.searchTag)
let debounce: ReturnType<typeof setTimeout> | null = null
function submit(immediate = false): void {
if (debounce) clearTimeout(debounce)
const run = () => {
debounce = null
void store.search({ keyword: input.value, tag: activeTag.value })
}
// 回车/点按钮时立即查,打字时防抖 250ms
if (immediate) run()
else debounce = setTimeout(run, 250)
}
function pickTag(tag: string): void {
activeTag.value = activeTag.value === tag ? '' : tag
submit(true)
}
function clearAll(): void {
input.value = ''
activeTag.value = ''
store.clearSearch()
}
watch(
() => store.searchTag,
tag => {
if (tag !== activeTag.value) activeTag.value = tag
}
)
onMounted(() => {
void store.loadTags()
// 首次进入若已有结果就保留,否则给一个空关键词查询(把最近改动的笔记列出来)
if (!store.searchHits.length) submit(true)
})
const hasQuery = computed(() => !!input.value.trim() || !!activeTag.value)
</script>
<template>
<div class="flex h-full min-h-0 flex-col">
<!-- 关键词 -->
<div class="shrink-0 px-2 pb-2">
<div class="relative">
<Search class="absolute top-1/2 left-2 size-3.5 -translate-y-1/2 text-muted-foreground" />
<Input
v-model="input"
placeholder="搜索标题与正文…"
class="h-7 pl-7 pr-6 text-xs"
@input="submit()"
@keydown.enter="submit(true)"
/>
<button
v-if="input"
type="button"
class="absolute top-1/2 right-1.5 -translate-y-1/2 text-muted-foreground hover:text-foreground"
@click="input = ''; submit(true)"
>
<X class="size-3" />
</button>
</div>
<!-- 标签筛选 -->
<div v-if="store.tags.length" class="mt-2 flex flex-wrap gap-1">
<button
v-for="item in store.tags.slice(0, 12)"
:key="item.tag"
type="button"
class="inline-flex items-center gap-1 rounded-sm px-1.5 py-0.5 text-[11px] transition-colors duration-150"
:class="
activeTag === item.tag
? 'bg-primary-soft text-primary-soft-text'
: 'bg-muted text-fg-secondary hover:bg-hover hover:text-foreground'
"
@click="pickTag(item.tag)"
>
<Tag class="size-2.5" />
{{ item.tag }}
<span class="tabular-nums opacity-70">{{ item.count }}</span>
</button>
</div>
</div>
<!-- 结果统计 -->
<div class="flex h-6 shrink-0 items-center gap-2 border-y border-border px-2 text-[11px] text-muted-foreground">
<span v-if="store.searching" class="flex items-center gap-1.5">
<Loader2 class="size-3 animate-spin" />检索中…
</span>
<span v-else>共 {{ store.searchTotal }} 条</span>
<button
v-if="hasQuery"
type="button"
class="ml-auto text-muted-foreground hover:text-foreground"
@click="clearAll"
>
重置
</button>
</div>
<!-- 结果列表 -->
<ScrollArea class="min-h-0 flex-1">
<div class="px-1.5 py-2">
<StateBlock
v-if="!store.searchHits.length && !store.searching"
variant="empty"
:title="hasQuery ? '没有匹配的笔记' : '还没有可搜索的内容'"
:description="hasQuery ? '换个关键词,或点「重置」看全部' : '索引同步完成后这里会列出库内笔记'"
:min-height="120"
/>
<button
v-for="hit in store.searchHits"
:key="hit.relPath"
type="button"
class="flex w-full flex-col gap-0.5 rounded-sm px-2 py-1.5 text-left transition-colors duration-150 hover:bg-row-hover"
@click="emit('open', hit.relPath)"
>
<span class="flex items-center gap-1.5">
<FileText class="size-3.5 shrink-0 text-muted-foreground" />
<span class="truncate text-xs font-medium text-foreground">{{ hit.title }}</span>
</span>
<span v-if="hit.snippet" class="line-clamp-2 pl-5 text-[11px] leading-relaxed text-muted-foreground">
<template v-for="(part, index) in splitHighlight(hit.snippet)" :key="index">
<mark v-if="part.hit" class="rounded-xs bg-primary-soft px-0.5 text-primary-soft-text">{{ part.text }}</mark>
<template v-else>{{ part.text }}</template>
</template>
</span>
<span class="truncate pl-5 text-[10px] text-fg-disabled">{{ hit.relPath }}</span>
</button>
<div v-if="store.searchHasMore" class="mt-1 flex justify-center">
<Button variant="ghost" size="sm" :disabled="store.searching" @click="store.searchMore()">
加载更多
</Button>
</div>
</div>
</ScrollArea>
</div>
</template>
-175
View File
@@ -1,175 +0,0 @@
/**
* 语言支持:扩展名 → CM6 语言扩展,**按需动态加载**。
*
* # 为什么必须懒加载
*
* `@codemirror/language-data` 的便利之处是「一个入口拿到所有语言」,代价是把
* 30 多个语言包全挂在依赖图上。若静态 `import`,Vite 会把它们塞进主 chunk ——
* 本项目首屏还要承载模块系统、终端、音乐等一堆东西,没有余量给「可能永远用不到
* 的 .cpp 语法」。这里手写一张显式映射表,每个语言一个 `import()`,Vite 自动切成
* 独立 chunk:用户打开 `.rs` 才下载 rust 的解析器(约 10~30 kB)。
*
* # 为什么不用 languageData 的 `LanguageDescription.matchFilename`
*
* 那个 API 是给「Markdown 内嵌代码块」用的,它按 name/alias 匹配,覆盖不到
* `.vue`、`.toml`、`.ps1` 这类扩展名(以及一大批我们想要的别名)。手写表虽然
* 啰嗦,但**行为完全可预期**:前端没有「这个扩展名到底映射到哪个语言」的推理,
* 只有一张查表。
*
* # 围栏代码块的内嵌高亮(P2)
*
* Markdown 里 ```rust 这类代码块本可由 `codeLanguages: languages` 内嵌高亮,
* 但 language-data 的清单需要异步加载,而 `markdown()` 是同步构建设置的。
* P1 先不做:没有内嵌高亮只是「代码块内是单色」,而异步清单会引入一次
* 「打开笔记 → 重配置编辑器」的抖动,得不偿失。
*
* # 未内置的语言
*
* 表格之外的一律退回纯文本(不加载任何扩展)。三类常见的缺口及理由:
* - `.scss` / `.less`:`@codemirror/lang-css` 只导出 `css()`,SCSS/Less 需要
* `@codemirror/lang-sass`(更重且语法覆盖不全)。CSS 变量为主的样式表用
* `css()` 就够,因此不引入;
* - `.sh` / `.ps1` / `.toml` / `.ini`:本来可以经 `@codemirror/legacy-modes` 的
* 流式解析补上,但那需要另一套高亮标签(Stream Language 的 token 名与 Lezer
* 高亮标签并非一一对应),P1 先不做;
* - 其余未知扩展名:纯文本。
*
* 统一原则:宁可「没高亮但能正常编辑」,也不要「高亮错乱」。
*/
import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
import { GFM } from '@lezer/markdown'
import { type Extension } from '@codemirror/state'
/**
* 语言加载器:返回扩展(可同步、可异步)。
*
* **允许返回 `null`**:表示「这个文件没有内置语言」。用 `null` 而不是空数组表达
* 「本来就没有」,是为了让调用方(`EditorHost`)能在日志里区分「没有语言」与
* 「有语言但被卸下」;两者在 CM6 的 Compartment 里行为相同,但语义不同。
*/
export type LanguageLoader = () => Extension | null | Promise<Extension | null>
interface LanguageEntry {
/** 状态栏展示名 */
label: string
load: LanguageLoader
}
/**
* 扩展名(小写,不含点)→ 语言。
*
* 值写成 thunk 而不是已加载的扩展:`import()` 只在真正调用时执行,
* 表本身的构建不产生任何网络/打包开销。
*/
const LOADERS: Record<string, LanguageEntry> = {
// ===== 前端 =====
js: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
mjs: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
cjs: { label: 'JavaScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript()) },
jsx: { label: 'JSX', load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ jsx: true })) },
ts: { label: 'TypeScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ typescript: true })) },
mts: { label: 'TypeScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ typescript: true })) },
cts: { label: 'TypeScript', load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ typescript: true })) },
tsx: {
label: 'TSX',
load: () => import('@codemirror/lang-javascript').then(m => m.javascript({ typescript: true, jsx: true }))
},
vue: { label: 'Vue', load: () => import('@codemirror/lang-vue').then(m => m.vue()) },
html: { label: 'HTML', load: () => import('@codemirror/lang-html').then(m => m.html()) },
htm: { label: 'HTML', load: () => import('@codemirror/lang-html').then(m => m.html()) },
css: { label: 'CSS', load: () => import('@codemirror/lang-css').then(m => m.css()) },
// ===== 数据与配置 =====
json: { label: 'JSON', load: () => import('@codemirror/lang-json').then(m => m.json()) },
jsonc: { label: 'JSON', load: () => import('@codemirror/lang-json').then(m => m.json()) },
yaml: { label: 'YAML', load: () => import('@codemirror/lang-yaml').then(m => m.yaml()) },
yml: { label: 'YAML', load: () => import('@codemirror/lang-yaml').then(m => m.yaml()) },
xml: { label: 'XML', load: () => import('@codemirror/lang-xml').then(m => m.xml()) },
svg: { label: 'SVG', load: () => import('@codemirror/lang-xml').then(m => m.xml()) },
sql: { label: 'SQL', load: () => import('@codemirror/lang-sql').then(m => m.sql()) },
// ===== 后端与系统 =====
py: { label: 'Python', load: () => import('@codemirror/lang-python').then(m => m.python()) },
pyw: { label: 'Python', load: () => import('@codemirror/lang-python').then(m => m.python()) },
rs: { label: 'Rust', load: () => import('@codemirror/lang-rust').then(m => m.rust()) },
go: { label: 'Go', load: () => import('@codemirror/lang-go').then(m => m.go()) },
java: { label: 'Java', load: () => import('@codemirror/lang-java').then(m => m.java()) },
c: { label: 'C', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
h: { label: 'C/C++ Header', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
cc: { label: 'C++', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
cpp: { label: 'C++', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
cxx: { label: 'C++', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) },
hpp: { label: 'C++ Header', load: () => import('@codemirror/lang-cpp').then(m => m.cpp()) }
}
/** 语言缓存:同一个语言只解析一次,之后复用已加载的扩展。 */
const cache = new Map<string, Promise<Extension | null>>()
/** 从文件名取扩展名(小写、不含点;无扩展名返回空串)。 */
export function extensionOf(fileName: string): string {
const base = fileName.split(/[\\/]/).pop() ?? ''
const dot = base.lastIndexOf('.')
if (dot <= 0 || dot === base.length - 1) return ''
return base.slice(dot + 1).toLowerCase()
}
/** 该文件名是否有内置语言支持。 */
export function hasLanguage(fileName: string): boolean {
return !!LOADERS[extensionOf(fileName)]
}
/** 文件名对应的语言展示信息(无支持时返回「纯文本」)。 */
export function languageLabel(fileName: string): string {
return LOADERS[extensionOf(fileName)]?.label ?? '纯文本'
}
/**
* 解析文件名对应的语言扩展。
*
* 返回 `null` 表示「没有内置语言」——调用方据此保持纯文本,而不是传空数组:
* 空数组与 `null` 在 Compartment 里语义相同,但 `null` 表达的是「本来就没有」,
* 而 `[]` 表达的是「有语言但选了无」,两者的日志与调试含义不同。
*/
export async function loadLanguage(fileName: string): Promise<Extension | null> {
const ext = extensionOf(fileName)
const entry = LOADERS[ext]
if (!entry) return null
const cached = cache.get(ext)
if (cached) return cached
const pending = Promise.resolve(entry.load()).catch(error => {
// 加载失败(离线 / chunk 404)时**不要**把失败的 promise 留在缓存里:
// 用户重连后再打开同一类型文件应当能成功
cache.delete(ext)
throw error
})
cache.set(ext, pending)
return pending
}
/**
* 笔记(Markdown)模式的语言扩展。
*
* # 为什么显式加 GFM 扩展
*
* `markdown()` 默认只用**基础 CommonMark** 语法:表格(`| a | b |`)、任务列表
* (`- [ ]`)、删除线(`~~x~~`)都不会被解析成对应节点,于是
* - Live Preview 拿不到 `Table` / `TaskMarker` 节点,表格与复选框渲染不出来;
* - 大纲提取虽然是自己扫文本(不依赖语法树),但**编辑器内的**高亮与折叠也会缺一块。
*
* `@lezer/markdown` 导出 `GFM`(= Table + TaskList + Strikethrough + Autolink 的扩展包),
* 交给 `extensions` 即可。注意它只影响**解析**,不改变渲染 —— 渲染仍由
* `markdownLivePreview.ts` 的装饰负责。
*
* 与代码文件走同一条 `loadLanguage` 通道(`md` → Markdown),因此笔记与代码
* 在「语言如何装配」上没有第二条路径。
*/
export function markdownLoader(): LanguageLoader {
return () =>
markdown({
base: markdownLanguage,
extensions: GFM
})
}
-41
View File
@@ -1,41 +0,0 @@
import type { ModuleConfig } from '@/types/module'
import type { SearchIndexItem } from '@/stores/searchIndex'
/**
* 全局搜索索引(本模块无内部 Tab,`tab` 一律省略 —— 搜索后直接落在模块页)。
*/
const searchItems: SearchIndexItem[] = [
{
title: '笔记',
description: 'Markdown 笔记库:所见即所得编辑、本地存储、WebDAV 备份',
keywords: ['笔记', 'notes', 'note', 'markdown', 'md', '文档', 'wiki', '知识库']
},
{
title: '打开笔记编辑器',
description: '在新窗口中打开笔记 / 编辑器(可多开)',
keywords: ['打开', '编辑器', '窗口', '独立窗口', 'editor', '工作区']
},
{
title: '新建笔记',
description: '在笔记库中新建一篇 Markdown 笔记',
keywords: ['新建', '新建笔记', 'new', '创建', 'create']
},
{
title: '笔记库设置',
description: '库根目录、编辑器主题、字体字号、自动保存',
keywords: ['设置', '主题', '字体', '字号', '库目录', '库根', '自动保存', 'vscode', 'darcula']
}
]
export const moduleConfig: ModuleConfig = {
id: 'notes',
name: '笔记',
icon: 'notes',
description: 'Markdown 笔记库与代码编辑器(所见即所得 + 多语言高亮 + 独立窗口)',
category: 'tool',
defaultEnabled: true,
loader: () => import('./NotesModule.vue'),
searchItems,
// 默认排在终端(40)之后
order: 45
}
-127
View File
@@ -1,127 +0,0 @@
/**
* 笔记模块的 IPC 客户端:命令名的**唯一落点**。
*
* # 为什么不直接在组件/ store 里写 `invoke('notes_xxx')`
*
* P0 阶段本项目还没有为新增命令重新生成 `src/lib/bindings.ts`(那需要一次
* debug 构建跑 `export_bindings`),于是新增命令的类型只能手写。手写类型散落在
* 十几处调用点时会同步腐坏:后端改个字段,前端在另一个文件里仍然编译通过。
* 因此这里做一层薄封装 —— **命令名与返回类型只在本文件出现一次**,
* 待 `bindings.ts` 重新生成后,改这一个文件即可完成切换。
*
* 参数名一律用 snake_case 形态的 camelCase(`relPath` / `dirRel` …),与
* tauri-specta 生成的调用约定一致;改错参数名会被 Tauri 在运行时报
* `invalid args`,所以这里刻意不做「参数对象透传」的花活,只做显式形参。
*/
import { invoke } from '@tauri-apps/api/core'
import type {
BackupReport,
BackupSnapshot,
ImportReport,
LibraryEntry,
LibraryInfo,
LinkEdge,
NoteBacklinks,
NoteDoc,
NoteFileDoc,
NoteIndexReport,
NoteIndexStats,
NoteSearchPage,
NoteSearchQuery,
NoteSettings,
NoteTagCount,
SyncOutcome,
TemplateSource,
WebdavStatus,
WebdavTestResult
} from '@/types/notes'
import type { NoteSearchHit, NoteTemplate } from '@/types/notes'
export const notesClient = {
// ===== 设置 =====
getSettings: () => invoke<NoteSettings>('notes_get_settings'),
saveSettings: (settings: NoteSettings) =>
invoke<NoteSettings>('notes_save_settings', { settings }),
// ===== 库 =====
libraryInfo: () => invoke<LibraryInfo>('notes_library_info'),
setLibraryRoot: (root: string | null) => invoke<LibraryInfo>('notes_set_library_root', { root }),
scanLibrary: () => invoke<LibraryEntry[]>('notes_scan_library'),
readNote: (relPath: string) => invoke<NoteDoc>('notes_read_note', { relPath }),
saveNote: (relPath: string, content: string) =>
invoke<NoteDoc>('notes_save_note', { relPath, content }),
createNote: (dirRel: string, name: string, templateId?: string) =>
invoke<NoteDoc>('notes_create_note', { dirRel, name, templateId: templateId ?? null }),
createFolder: (dirRel: string, name: string) =>
invoke<null>('notes_create_folder', { dirRel, name }),
renameEntry: (relPath: string, newName: string) =>
invoke<string>('notes_rename_entry', { relPath, newName }),
deleteEntry: (relPath: string) => invoke<null>('notes_delete_entry', { relPath }),
/** 打开(或创建)今天的日记 */
dailyNote: () => invoke<NoteDoc>('notes_daily_note'),
// ===== 索引与检索 =====
rebuildIndex: () => invoke<NoteIndexReport>('notes_rebuild_index'),
syncIndex: () => invoke<NoteIndexReport>('notes_sync_index'),
/** 全文检索 / 标签 / 目录筛选(`query` 与 Rust 侧 `NoteSearchQuery` 一一对应) */
search: (query: NoteSearchQuery) => invoke<NoteSearchPage>('notes_search_notes', { query }),
listNotes: (limit?: number) => invoke<NoteSearchHit[]>('notes_list_notes', { limit: limit ?? null }),
tags: () => invoke<NoteTagCount[]>('notes_tags'),
indexStats: () => invoke<NoteIndexStats>('notes_index_stats'),
/** 一篇笔记的出链 / 入链 */
backlinks: (relPath: string) => invoke<NoteBacklinks>('notes_backlinks', { relPath }),
/** 全库链接图(已解析的内部链接边) */
linkGraph: () => invoke<LinkEdge[]>('notes_link_graph'),
/**
* 取出「启动时命令行 / 文件关联指定的文件」(取走即清空)。
*
* 冷启动时 Rust 无法 `emit`(前端还没注册监听),因此改为前端主动取一次。
*/
takePendingFile: () => invoke<string | null>('notes_take_pending_file'),
// ===== 库外任意文件 =====
openFile: (path: string) => invoke<NoteFileDoc>('notes_open_file', { path }),
writeFile: (path: string, content: string, encoding: string, eol: string) =>
invoke<NoteFileDoc>('notes_write_file', { path, content, encoding, eol }),
/** 登记系统对话框选中的路径为「可写」(它不是经 `openFile` 打开的) */
authorizeFile: (path: string) => invoke<null>('notes_authorize_file', { path }),
/** 把 base64 图片写进库根 `assets/`,返回可插入 Markdown 的相对路径 */
writeAsset: (fileName: string, ext: string, dataBase64: string) =>
invoke<string>('notes_write_asset', { fileName, ext, dataBase64 }),
/**
* 把库内图片读成 `data:` URL(内联预览用)。
*
* 返回 `null` 表示「不适合预览」(非图片扩展名 / 超过大小上限)——
* 不是错误,调用方按普通文本渲染即可。
*/
readAsset: (relPath: string) => invoke<string | null>('notes_read_asset', { relPath }),
// ===== 模板(P2) =====
listTemplates: () => invoke<NoteTemplate[]>('notes_list_templates'),
/** 不带参数 = 把全部内置模板导出到库内 `templates/` */
addTemplate: (name?: string, body?: string) =>
invoke<string[]>('notes_add_template', { name: name ?? null, body: body ?? null }),
readTemplate: (templateId: string) =>
invoke<TemplateSource>('notes_read_template', { templateId }),
// ===== 导入 / 导出(P2) =====
import: (source: string, destDir: string) =>
invoke<ImportReport>('notes_import', { source, destDir }),
/** 把渲染好的 HTML 写到用户选定的位置(渲染在前端,落盘在后端) */
exportNote: (relPath: string, html: string, dest: string) =>
invoke<string>('notes_export_note', { relPath, html, dest }),
exportZip: (dest: string, dirRel?: string) =>
invoke<string>('notes_export_zip', { dest, dirRel: dirRel ?? null }),
exportSnapshotLocal: (dest?: string) =>
invoke<string>('notes_export_snapshot_local', { dest: dest ?? null }),
// ===== WebDAV(P2) =====
webdavStatus: () => invoke<WebdavStatus>('notes_webdav_status'),
setWebdavPassword: (password: string) =>
invoke<null>('notes_set_webdav_password', { password }),
testWebdav: () => invoke<WebdavTestResult>('notes_test_webdav'),
syncNow: () => invoke<SyncOutcome>('notes_sync_now'),
backupNow: () => invoke<BackupReport>('notes_backup_now'),
listBackups: () => invoke<BackupSnapshot[]>('notes_list_backups'),
restoreBackup: (name: string) => invoke<ImportReport>('notes_restore_backup', { name })
}
+179 -12
View File
@@ -7,8 +7,8 @@ import { STORAGE_KEYS } from '@/lib/constants'
import { applyAccent, readStoredAccent } from '@/lib/theme'
import { Effect, EffectState } from '@tauri-apps/api/window'
import {
Globe, Power, PowerOff, RefreshCw, Check, Monitor, Download,
Settings, LogOut,
Globe, Power, PowerOff, RefreshCw, Check, Monitor, LogOut,
Play, Pause, SkipBack, SkipForward, Music, SquareTerminal, Bot, FileCode2,
} from '@lucide/vue'
import {
Select, SelectContent, SelectItem, SelectTrigger, SelectValue,
@@ -28,6 +28,13 @@ interface TrayMenuState {
proxyCurrent: string | null
}
/** 音乐控制条状态(与 Rust `tray_menu::MusicState` 对应) */
interface MusicState {
playing: boolean
title: string
artist: string
}
const state = reactive<TrayMenuState>({
proxyRunning: false,
systemProxy: false,
@@ -36,6 +43,7 @@ const state = reactive<TrayMenuState>({
proxyNodes: [],
proxyCurrent: null,
})
const music = reactive<MusicState>({ playing: false, title: '', artist: '' })
const loadingAction = ref<string | null>(null)
const refreshing = ref(false)
const osdVisible = ref(false)
@@ -301,6 +309,43 @@ function handleSelectNode(name: unknown) {
}
}
// ===== 音乐控制条 =====
//
// 与普通菜单项不同:点音乐按钮**不关闭菜单**(用户常要连点下一首),
// 因此不走 handleAction(它会 hide 菜单 + 取消焦点),而是单独一条路径。
/** 拉取一次音乐状态(本地查询,开销极小) */
async function refreshMusic() {
try {
Object.assign(music, await invoke<MusicState>('tray_music_state'))
} catch { /* 忽略 */ }
}
async function handleMusicControl(action: 'toggle' | 'next' | 'prev') {
// 乐观翻转播放态:动作要经主窗口前端执行(异步),先改本地避免按钮有明显延迟;
// 真实值由 1s 轮询纠正
if (action === 'toggle') music.playing = !music.playing
try {
await invoke('tray_music_control', { action })
} catch { /* 忽略 */ }
}
/** 音乐状态轮询定时器(仅菜单可见时运行) */
let musicTimer: number | null = null
function startMusicPolling() {
void refreshMusic()
if (musicTimer !== null) return
musicTimer = window.setInterval(() => void refreshMusic(), 1000)
}
function stopMusicPolling() {
if (musicTimer !== null) {
window.clearInterval(musicTimer)
musicTimer = null
}
}
function delayText(delay: number | null): string {
if (delay === null) return '未测试'
if (delay === 0) return '超时'
@@ -451,6 +496,8 @@ onMounted(async () => {
osdVisible.value = readOsdVisible()
// 显示前重置上次残留的下拉/焦点状态(双保险)
resetMenuState()
// 音乐控制条:显示时拉一次并开始轮询(隐藏后停止,不做无谓后台查询)
startMusicPolling()
// 开始合并窗口:等待完整状态,结束时才显示
menuJustShown = Date.now()
window.clearTimeout(finalizeTimer)
@@ -462,7 +509,10 @@ onMounted(async () => {
// 菜单失焦(点击其他位置自动隐藏)时重置下拉框与焦点,避免下次打开时残留
unlistenFns.push(await getCurrentWindow().onFocusChanged(({ payload: focused }) => {
if (!focused) resetMenuState()
if (!focused) {
resetMenuState()
stopMusicPolling()
}
}))
// - 显示流程的合并窗口内:完整状态补充到达,仅合并数据,让 finalizeTimer 统一显示
@@ -481,6 +531,7 @@ onMounted(async () => {
})
onUnmounted(() => {
stopMusicPolling()
unlistenFns.forEach((fn) => fn())
})
</script>
@@ -488,6 +539,39 @@ 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>
<div class="tray-music-actions">
<button
class="tray-music-btn"
:disabled="!music.title"
title="上一首"
@click="handleMusicControl('prev')"
>
<SkipBack class="size-4" />
</button>
<button class="tray-music-btn primary" title="播放 / 暂停" @click="handleMusicControl('toggle')">
<Pause v-if="music.playing" class="size-4" />
<Play v-else class="size-4" />
</button>
<button
class="tray-music-btn"
:disabled="!music.title"
title="下一首"
@click="handleMusicControl('next')"
>
<SkipForward class="size-4" />
</button>
</div>
</div>
<div class="tray-separator"></div>
<div class="tray-section">
<div class="tray-section-header">
<Globe class="size-4 text-primary" />
@@ -581,16 +665,17 @@ onUnmounted(() => {
<div class="tray-separator"></div>
<button class="tray-item" @click="handleAction('download_new')">
<Download class="size-4" />
<span>新建下载</span>
<button class="tray-item" @click="handleAction('terminal')">
<SquareTerminal class="size-4" />
<span>终端</span>
</button>
<div class="tray-separator"></div>
<button class="tray-item" @click="handleAction('settings')">
<Settings class="size-4" />
<span>常规设置</span>
<button class="tray-item" @click="handleAction('dsh')">
<Bot class="size-4" />
<span>dsh</span>
</button>
<button class="tray-item" @click="handleAction('editor')">
<FileCode2 class="size-4" />
<span>编辑器</span>
</button>
<button class="tray-item tray-quit" @click="handleAction('quit')">
<LogOut class="size-4" />
@@ -672,6 +757,88 @@ onUnmounted(() => {
opacity: 0.5;
}
/* ===== 音乐控制条(代理之上) ===== */
.tray-music {
display: flex;
align-items: center;
gap: 8px;
padding: 7px 10px;
border-radius: 6px;
}
.tray-music-icon {
color: var(--primary);
}
.tray-music-text {
flex: 1;
min-width: 0;
display: flex;
flex-direction: column;
gap: 1px;
}
.tray-music-title {
font-size: 12.5px;
font-weight: 600;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.tray-music-artist {
font-size: 10.5px;
color: var(--muted-foreground);
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
/* 没有歌手时也占位,避免切换曲目时控制条高度跳动 */
min-height: 13px;
}
.tray-music-actions {
display: flex;
align-items: center;
gap: 2px;
flex-shrink: 0;
}
.tray-music-btn {
display: inline-flex;
align-items: center;
justify-content: center;
width: 26px;
height: 26px;
border: none;
border-radius: 5px;
background: transparent;
color: var(--foreground);
cursor: pointer;
transition: background 0.08s;
}
.tray-music-btn:hover:not(:disabled) {
background: var(--row-hover-veil);
}
.tray-music-btn:active:not(:disabled) {
background: var(--row-selected-veil);
}
.tray-music-btn:disabled {
opacity: 0.35;
cursor: not-allowed;
}
.tray-music-btn svg {
color: currentColor;
}
.tray-music-btn.primary {
background: color-mix(in oklch, var(--primary) 14%, transparent);
color: var(--primary);
}
.tray-music-btn.primary:hover:not(:disabled) {
background: color-mix(in oklch, var(--primary) 22%, transparent);
}
.tray-item {
display: flex;
align-items: center;