1382 lines
42 KiB
TypeScript
1382 lines
42 KiB
TypeScript
/**
|
||
* 快速面板 Provider：多源搜索结果聚合。
|
||
*
|
||
* 每个 Provider 实现统一 search(query) 接口，返回带 group 的 QPItem 列表。
|
||
* 引擎对结果统一打分排序，action 执行后由调用方隐藏窗口。
|
||
*
|
||
* 独立窗口约束：不加载主应用 store。
|
||
* - command Provider 从 localStorage 读取主应用写入的命令缓存，
|
||
* 执行时 emit `quickpanel-execute-command` 事件通知主窗口切换模块。
|
||
* - system/web/calc Provider 纯前端 + Rust invoke。
|
||
*/
|
||
|
||
import { invoke } from '@tauri-apps/api/core'
|
||
import { emit } from '@tauri-apps/api/event'
|
||
import { getTextForms, bestScore, type TextForms } from './engine'
|
||
import { openUrl } from '@tauri-apps/plugin-opener'
|
||
|
||
// ===== 结果项与 Provider 接口 =====
|
||
|
||
/** 子动作（项的右键/展开菜单） */
|
||
export interface QPSubAction {
|
||
id: string
|
||
label: string
|
||
action: () => void | Promise<void>
|
||
}
|
||
|
||
export interface QPItem {
|
||
id: string
|
||
title: string
|
||
subtitle?: string
|
||
group: string
|
||
score?: number
|
||
/** 应用图标 data URL（'' = 加载中，undefined = 无图标项） */
|
||
iconUrl?: string
|
||
/** 应用路径（仅 app 项设置，用于按需获取图标） */
|
||
iconPath?: string
|
||
/** 执行动作（调用方在执行后负责隐藏窗口） */
|
||
action: () => void | Promise<void>
|
||
/** 子动作菜单（可选）。执行子动作后同样隐藏窗口 */
|
||
subActions?: QPSubAction[]
|
||
/** 删除确认信息（仅可删除项设置，如文件/文件夹，用于弹窗确认后执行删除） */
|
||
deleteInfo?: { path: string; isDir: boolean }
|
||
/** 用于历史记录的查询文本（仅历史项设置，点击历史时用此重新搜索恢复 action） */
|
||
historyQuery?: string
|
||
/** 应用可靠性排序（仅 group='应用' 项设置，越小越可靠：开始菜单 0 / 桌面 1 / 其他 2） */
|
||
appRank?: number
|
||
}
|
||
|
||
export interface QPProvider {
|
||
id: string
|
||
label: string
|
||
priority: number
|
||
/** 返回当前 query 的候选结果（引擎尚未打分，score 可留空） */
|
||
search(query: string): QPItem[] | Promise<QPItem[]>
|
||
}
|
||
|
||
// ===== 工具：为 item 构建匹配形态（用于引擎打分） =====
|
||
|
||
/** 由 title + keywords 组合出待匹配文本形态（host 对象用于缓存） */
|
||
function buildItemForms(title: string, keywords: string[] = []): TextForms {
|
||
const host = { title, keywords }
|
||
const combined = [title, ...keywords].join(' ')
|
||
return getTextForms(combined, host)
|
||
}
|
||
|
||
// ===== command Provider：复用主应用模块搜索项 =====
|
||
|
||
const COMMANDS_KEY = 'thing_quickpanel_commands'
|
||
|
||
interface CachedCommand {
|
||
moduleId: string
|
||
moduleName: string
|
||
title: string
|
||
description?: string
|
||
keywords: string[]
|
||
}
|
||
|
||
function loadCommands(): CachedCommand[] {
|
||
try {
|
||
const raw = localStorage.getItem(COMMANDS_KEY)
|
||
if (!raw) return []
|
||
return JSON.parse(raw) as CachedCommand[]
|
||
} catch {
|
||
return []
|
||
}
|
||
}
|
||
|
||
class CommandProvider implements QPProvider {
|
||
id = 'command'
|
||
label = '命令'
|
||
priority = 100
|
||
|
||
search(query: string): QPItem[] {
|
||
const commands = loadCommands()
|
||
if (!query.trim() || !commands.length) {
|
||
// 无输入时返回前几条命令作为快捷入口
|
||
if (!query.trim()) {
|
||
return commands.slice(0, 6).map((c, i) => this.toItem(c, i))
|
||
}
|
||
return []
|
||
}
|
||
|
||
const results: Array<{ item: QPItem; score: number }> = []
|
||
commands.forEach((c, idx) => {
|
||
const forms = buildItemForms(c.title, c.keywords)
|
||
const score = bestScore(query, forms)
|
||
if (score >= 0) {
|
||
const item = this.toItem(c, idx)
|
||
results.push({ item, score })
|
||
}
|
||
})
|
||
results.sort((a, b) => b.score - a.score)
|
||
return results.map(r => ({ ...r.item, score: r.score }))
|
||
}
|
||
|
||
private toItem(c: CachedCommand, idx: number): QPItem {
|
||
return {
|
||
id: `cmd-${c.moduleId}-${idx}`,
|
||
title: c.title,
|
||
subtitle: c.description || c.moduleName,
|
||
group: '命令',
|
||
action: async () => {
|
||
// 通知主窗口切换到对应模块
|
||
await emit('quickpanel-execute-command', { moduleId: c.moduleId })
|
||
},
|
||
}
|
||
}
|
||
}
|
||
|
||
// ===== calc Provider：输入即算 =====
|
||
|
||
const CALC_RE = /^[\d\s+\-*/().%]+$/
|
||
|
||
class CalcProvider implements QPProvider {
|
||
id = 'calc'
|
||
label = '计算'
|
||
priority = 90
|
||
|
||
search(query: string): QPItem[] {
|
||
const trimmed = query.trim()
|
||
if (!trimmed) return []
|
||
// 必须至少包含一个运算符和一个数字
|
||
if (!CALC_RE.test(trimmed)) return []
|
||
if (!/[\d]/.test(trimmed) || !/[+\-*/%]/.test(trimmed)) return []
|
||
|
||
try {
|
||
// 限制字符已由正则保证，用 Function 计算避免 eval 作用域污染
|
||
// eslint-disable-next-line no-new-func
|
||
const result = Function(`"use strict"; return (${trimmed})`)()
|
||
if (typeof result !== 'number' || !isFinite(result)) return []
|
||
const display = String(result)
|
||
return [{
|
||
id: 'calc-result',
|
||
title: display,
|
||
subtitle: `= ${trimmed}`,
|
||
group: '计算',
|
||
score: 0.95,
|
||
action: async () => {
|
||
try {
|
||
await navigator.clipboard.writeText(display)
|
||
} catch {
|
||
/* 忽略剪贴板失败 */
|
||
}
|
||
},
|
||
}]
|
||
} catch {
|
||
return []
|
||
}
|
||
}
|
||
}
|
||
|
||
// ===== web Provider：默认搜索建议 =====
|
||
|
||
type SearchEngine = 'google' | 'bing' | 'baidu'
|
||
const ENGINE_URL: Record<SearchEngine, string> = {
|
||
google: 'https://www.google.com/search?q=',
|
||
bing: 'https://www.bing.com/search?q=',
|
||
baidu: 'https://www.baidu.com/s?wd=',
|
||
}
|
||
|
||
function getSearchEngine(): SearchEngine {
|
||
try {
|
||
const raw = localStorage.getItem('thing_quickpanel_settings')
|
||
if (raw) {
|
||
const s = JSON.parse(raw)
|
||
if (s.searchEngine && ENGINE_URL[s.searchEngine as SearchEngine]) {
|
||
return s.searchEngine
|
||
}
|
||
}
|
||
} catch {
|
||
/* 忽略 */
|
||
}
|
||
return 'bing'
|
||
}
|
||
|
||
class WebProvider implements QPProvider {
|
||
id = 'web'
|
||
label = '网页'
|
||
priority = 50
|
||
|
||
search(query: string): QPItem[] {
|
||
const trimmed = query.trim()
|
||
if (!trimmed) return []
|
||
const engine = getSearchEngine()
|
||
return [{
|
||
id: 'web-search',
|
||
title: `搜索「${trimmed}」`,
|
||
subtitle: `在 ${engine} 中打开`,
|
||
group: '网页',
|
||
score: 0.3,
|
||
action: async () => {
|
||
try {
|
||
await openUrl(ENGINE_URL[engine] + encodeURIComponent(trimmed))
|
||
} catch {
|
||
/* 忽略 */
|
||
}
|
||
},
|
||
}]
|
||
}
|
||
}
|
||
|
||
// ===== system Provider：系统操作 =====
|
||
|
||
interface SystemCommandDef {
|
||
id: string
|
||
title: string
|
||
subtitle: string
|
||
/** 额外关键词（英文命令名、中文别名等，用于匹配） */
|
||
keywords: string[]
|
||
command: string
|
||
args: string[]
|
||
}
|
||
|
||
/** 内置系统命令。title 为中文主名，keywords 补充英文/别名，
|
||
* 拼音全拼与首字母由引擎从 title 的 CJK 部分自动推导。 */
|
||
const SYSTEM_COMMANDS: SystemCommandDef[] = [
|
||
{
|
||
id: 'sys-regedit',
|
||
title: '注册表编辑器',
|
||
subtitle: 'regedit',
|
||
keywords: ['regedit', '注册表', 'registry'],
|
||
command: 'regedit',
|
||
args: [],
|
||
},
|
||
{
|
||
id: 'sys-cmd',
|
||
title: '命令提示符',
|
||
subtitle: 'cmd',
|
||
keywords: ['cmd', '命令行', '终端', 'command'],
|
||
command: 'cmd',
|
||
args: [],
|
||
},
|
||
{
|
||
id: 'sys-powershell',
|
||
title: 'PowerShell',
|
||
subtitle: 'powershell',
|
||
keywords: ['powershell', 'pwsh'],
|
||
command: 'powershell',
|
||
args: [],
|
||
},
|
||
{
|
||
id: 'sys-taskmgr',
|
||
title: '任务管理器',
|
||
subtitle: 'taskmgr',
|
||
keywords: ['taskmgr', '任务管理', '进程'],
|
||
command: 'taskmgr',
|
||
args: [],
|
||
},
|
||
{
|
||
id: 'sys-explorer',
|
||
title: '资源管理器',
|
||
subtitle: 'explorer',
|
||
keywords: ['explorer', '文件管理器', '资源管理'],
|
||
command: 'explorer',
|
||
args: [],
|
||
},
|
||
{
|
||
id: 'sys-control',
|
||
title: '控制面板',
|
||
subtitle: 'control',
|
||
keywords: ['control', '控制面板', '设置'],
|
||
command: 'control',
|
||
args: [],
|
||
},
|
||
{
|
||
id: 'sys-shutdown',
|
||
title: '关机',
|
||
subtitle: 'shutdown /s /t 0',
|
||
keywords: ['shutdown', '关闭计算机', '关闭电脑', 'guanji'],
|
||
command: 'shutdown',
|
||
args: ['/s', '/t', '0'],
|
||
},
|
||
{
|
||
id: 'sys-restart',
|
||
title: '重启',
|
||
subtitle: 'shutdown /r /t 0',
|
||
keywords: ['restart', 'reboot', '重新启动', '重启电脑', 'chongqi'],
|
||
command: 'shutdown',
|
||
args: ['/r', '/t', '0'],
|
||
},
|
||
{
|
||
id: 'sys-shutdown-cancel',
|
||
title: '取消关机/重启',
|
||
subtitle: 'shutdown /a',
|
||
keywords: ['cancel', '取消', 'quxiao', 'abort'],
|
||
command: 'shutdown',
|
||
args: ['/a'],
|
||
},
|
||
{
|
||
id: 'sys-hibernate',
|
||
title: '休眠',
|
||
subtitle: 'shutdown /h',
|
||
keywords: ['hibernate', '睡眠', 'xiu', 'mian'],
|
||
command: 'shutdown',
|
||
args: ['/h'],
|
||
},
|
||
]
|
||
|
||
class SystemProvider implements QPProvider {
|
||
id = 'system'
|
||
label = '系统'
|
||
priority = 40
|
||
|
||
private buildItems(): QPItem[] {
|
||
const items: QPItem[] = SYSTEM_COMMANDS.map(def => ({
|
||
id: def.id,
|
||
title: def.title,
|
||
subtitle: def.subtitle,
|
||
group: '系统',
|
||
action: async () => {
|
||
try {
|
||
await invoke('quickpanel_run_system_command', {
|
||
command: def.command,
|
||
args: def.args,
|
||
})
|
||
} catch (e) {
|
||
console.error('[quickpanel] 系统命令失败:', e)
|
||
}
|
||
},
|
||
}))
|
||
// 锁屏 + 退出 应用本身
|
||
items.push(
|
||
{
|
||
id: 'sys-lock',
|
||
title: '锁定屏幕',
|
||
subtitle: '立即锁定计算机',
|
||
group: '系统',
|
||
action: async () => {
|
||
try {
|
||
await invoke('quickpanel_lock_screen')
|
||
} catch (e) {
|
||
console.error('[quickpanel] 锁屏失败:', e)
|
||
}
|
||
},
|
||
},
|
||
{
|
||
id: 'sys-quit',
|
||
title: '退出 Thing',
|
||
subtitle: '关闭应用程序',
|
||
group: '系统',
|
||
action: async () => {
|
||
try {
|
||
await invoke('quit_app')
|
||
} catch (e) {
|
||
console.error('[quickpanel] 退出失败:', e)
|
||
}
|
||
},
|
||
},
|
||
)
|
||
return items
|
||
}
|
||
|
||
/** 为带 keywords 的 item 构建匹配形态（title + keywords 合并） */
|
||
private itemForms(item: QPItem): TextForms {
|
||
const def = SYSTEM_COMMANDS.find(d => d.id === item.id)
|
||
return buildItemForms(item.title, def?.keywords ?? [])
|
||
}
|
||
|
||
search(query: string): QPItem[] {
|
||
const items = this.buildItems()
|
||
|
||
if (!query.trim()) return items
|
||
const scored: Array<{ item: QPItem; score: number }> = []
|
||
for (const item of items) {
|
||
const forms = this.itemForms(item)
|
||
const score = bestScore(query, forms)
|
||
if (score >= 0) scored.push({ item, score })
|
||
}
|
||
scored.sort((a, b) => b.score - a.score)
|
||
return scored.map(s => ({ ...s.item, score: s.score }))
|
||
}
|
||
}
|
||
|
||
// ===== 应用通用：构建启动动作与子动作（开始菜单 / 文件索引 .lnk 共用） =====
|
||
|
||
/** 启动一个应用（.lnk / .exe 等），通过 Rust spawn 子进程 */
|
||
function makeAppLaunch(path: string) {
|
||
return async () => {
|
||
try {
|
||
// .lnk 文件不能用 openUrl 打开，需直接 spawn
|
||
await invoke('quickpanel_run_custom_command', { command: path, args: [] })
|
||
} catch (e) {
|
||
console.error('[quickpanel] 启动应用失败:', e)
|
||
}
|
||
}
|
||
}
|
||
|
||
/** 应用项的标准子动作：启动 / 在资源管理器中显示 / 复制路径（+ 可选删除） */
|
||
function makeAppSubActions(path: string, includeDelete = false): QPSubAction[] {
|
||
const launch = makeAppLaunch(path)
|
||
const subs: QPSubAction[] = [
|
||
{ id: 'launch', label: '启动', action: launch },
|
||
{
|
||
id: 'reveal',
|
||
label: '在资源管理器中显示',
|
||
action: async () => {
|
||
try {
|
||
await invoke('quickpanel_reveal_in_explorer', { path })
|
||
} catch (e) {
|
||
console.error('[quickpanel] 资源管理器显示失败:', e)
|
||
}
|
||
},
|
||
},
|
||
{
|
||
id: 'copy-path',
|
||
label: '复制路径',
|
||
action: async () => {
|
||
try {
|
||
await navigator.clipboard.writeText(path)
|
||
} catch {
|
||
/* 忽略 */
|
||
}
|
||
},
|
||
},
|
||
]
|
||
if (includeDelete) {
|
||
subs.push({
|
||
id: 'delete',
|
||
label: '删除',
|
||
action: async () => {
|
||
try {
|
||
await invoke('quickpanel_delete_file', { path })
|
||
} catch (e) {
|
||
console.error('[quickpanel] 删除失败:', e)
|
||
}
|
||
},
|
||
})
|
||
}
|
||
return subs
|
||
}
|
||
|
||
/** 根据路径推断应用可靠性排序：桌面 1 / 其他位置 2（开始菜单由调用方直接给 0） */
|
||
function appRankFromPath(path: string): number {
|
||
const p = path.toLowerCase()
|
||
if (p.includes('\\desktop\\') || p.includes('/desktop/')) return 1
|
||
return 2
|
||
}
|
||
|
||
// ===== app Provider：扫描开始菜单应用 =====
|
||
|
||
interface AppRecord {
|
||
name: string
|
||
path: string
|
||
}
|
||
|
||
let appCache: AppRecord[] | null = null
|
||
let appCacheTime = 0
|
||
const APP_CACHE_TTL = 60_000 // 1 分钟缓存
|
||
|
||
async function loadApps(): Promise<AppRecord[]> {
|
||
if (appCache && Date.now() - appCacheTime < APP_CACHE_TTL) {
|
||
return appCache
|
||
}
|
||
try {
|
||
const apps = await invoke<AppRecord[]>('quickpanel_scan_apps')
|
||
appCache = apps
|
||
appCacheTime = Date.now()
|
||
return apps
|
||
} catch (e) {
|
||
console.error('[quickpanel] 扫描应用失败:', e)
|
||
return []
|
||
}
|
||
}
|
||
|
||
class AppProvider implements QPProvider {
|
||
id = 'app'
|
||
label = '应用'
|
||
priority = 95
|
||
|
||
async search(query: string): Promise<QPItem[]> {
|
||
const apps = await loadApps()
|
||
if (!query.trim()) {
|
||
// 空查询：不显示应用（避免列表过长），由命令入口承担
|
||
return []
|
||
}
|
||
const results: Array<{ item: QPItem; score: number }> = []
|
||
let idx = 0
|
||
for (const app of apps) {
|
||
const forms = buildItemForms(app.name)
|
||
const score = bestScore(query, forms)
|
||
if (score >= 0) {
|
||
results.push({
|
||
item: {
|
||
id: `app-${idx}`,
|
||
title: app.name,
|
||
subtitle: app.path,
|
||
group: '应用',
|
||
iconPath: app.path,
|
||
action: makeAppLaunch(app.path),
|
||
subActions: makeAppSubActions(app.path),
|
||
appRank: 0, // 开始菜单：最可靠来源
|
||
},
|
||
score,
|
||
})
|
||
}
|
||
idx++
|
||
}
|
||
results.sort((a, b) => b.score - a.score)
|
||
return results.slice(0, 15).map(r => ({ ...r.item, score: r.score }))
|
||
}
|
||
}
|
||
|
||
// ===== 应用图标按需加载 =====
|
||
// 前端缓存（path -> dataUrl）。Rust 侧另有内存 + 磁盘缓存，此处仅避免重复 IPC。
|
||
|
||
const appIconCache = new Map<string, string>() // path -> dataUrl('' = 无图标)
|
||
|
||
/** 为搜索结果中带 iconPath 的项（应用、历史中的应用）按需加载图标（data URL），
|
||
* 并写入 item.iconUrl 触发响应式更新。
|
||
* 命中前端缓存时同步返回；否则异步调用 Rust 命令（命中 Rust 缓存则零开销）。 */
|
||
export async function loadAppIconsForResults(items: QPItem[]): Promise<void> {
|
||
const toLoad: QPItem[] = []
|
||
for (const item of items) {
|
||
if (!item.iconPath) continue
|
||
if (item.iconUrl !== undefined) continue // 已设置（含加载中）
|
||
const cached = appIconCache.get(item.iconPath)
|
||
if (cached !== undefined) {
|
||
item.iconUrl = cached
|
||
} else {
|
||
item.iconUrl = '' // 标记加载中，避免重复请求
|
||
toLoad.push(item)
|
||
}
|
||
}
|
||
if (!toLoad.length) return
|
||
await Promise.all(
|
||
toLoad.map(async item => {
|
||
const path = item.iconPath!
|
||
try {
|
||
const url = await invoke<string | null>('quickpanel_get_app_icon', { path })
|
||
const u = url ?? ''
|
||
appIconCache.set(path, u)
|
||
item.iconUrl = u
|
||
} catch {
|
||
appIconCache.set(path, '')
|
||
item.iconUrl = ''
|
||
}
|
||
}),
|
||
)
|
||
}
|
||
|
||
/** 清空前端图标缓存（Rust 端清理命令 quickpanel_clear_app_icon_cache 调用后可一并清空） */
|
||
export function invalidateAppIconCache() {
|
||
appIconCache.clear()
|
||
}
|
||
|
||
// ===== file Provider：文件索引搜索 =====
|
||
|
||
interface FileRecord {
|
||
path: string
|
||
name: string
|
||
ext: string
|
||
size: number
|
||
isDir: boolean
|
||
}
|
||
|
||
let fileIndexReady = false
|
||
|
||
class FileProvider implements QPProvider {
|
||
id = 'file'
|
||
label = '文件'
|
||
priority = 85
|
||
|
||
async search(query: string): Promise<QPItem[]> {
|
||
if (!query.trim() || query.trim().length < 2) return []
|
||
if (!fileIndexReady) return []
|
||
try {
|
||
const files = await invoke<FileRecord[]>('quickpanel_search_files', {
|
||
query: query.trim(),
|
||
limit: 20,
|
||
})
|
||
return files.map((f, idx) => {
|
||
// .lnk 快捷方式按应用处理：带图标、用启动命令，并与开始菜单应用统一去重
|
||
// 注意：Rust 返回的 ext 不带点（如 "lnk"），这里直接按文件名判断最稳妥
|
||
const isLnk = !f.isDir && f.name.toLowerCase().endsWith('.lnk')
|
||
if (isLnk) {
|
||
return {
|
||
id: `file-app-${idx}`,
|
||
title: f.name,
|
||
subtitle: f.path,
|
||
group: '应用',
|
||
score: 0.55, // 略低于开始菜单应用(0.6+)，去重时让位于开始菜单
|
||
iconPath: f.path,
|
||
action: makeAppLaunch(f.path),
|
||
subActions: makeAppSubActions(f.path, true),
|
||
deleteInfo: { path: f.path, isDir: false },
|
||
appRank: appRankFromPath(f.path),
|
||
}
|
||
}
|
||
const openFile = async () => {
|
||
try {
|
||
// 目录：Rust 端用 explorer.exe 打开；文件：默认程序打开（无关联时 fallback 打开方式）
|
||
await invoke('quickpanel_open_file', { path: f.path })
|
||
} catch (e) {
|
||
console.error('[quickpanel] 打开文件失败:', e)
|
||
}
|
||
}
|
||
return {
|
||
id: `file-${idx}`,
|
||
title: f.name,
|
||
subtitle: f.path,
|
||
group: '文件',
|
||
score: 0.6,
|
||
action: openFile,
|
||
// 目录：打开即导航到该目录，无需再提供「在资源管理器中显示」，避免重复
|
||
subActions: [
|
||
{
|
||
id: 'open',
|
||
label: f.isDir ? '打开文件夹' : '打开',
|
||
action: openFile,
|
||
},
|
||
...(f.isDir
|
||
? []
|
||
: [{
|
||
id: 'reveal',
|
||
label: '在资源管理器中显示',
|
||
action: async () => {
|
||
try {
|
||
await invoke('quickpanel_reveal_in_explorer', { path: f.path })
|
||
} catch (e) {
|
||
console.error('[quickpanel] 资源管理器显示失败:', e)
|
||
}
|
||
},
|
||
}]),
|
||
{
|
||
id: 'copy-path',
|
||
label: '复制路径',
|
||
action: async () => {
|
||
try {
|
||
await navigator.clipboard.writeText(f.path)
|
||
} catch {
|
||
/* 忽略 */
|
||
}
|
||
},
|
||
},
|
||
{
|
||
id: 'delete',
|
||
label: '删除',
|
||
action: async () => {
|
||
try {
|
||
// 移到回收站（PowerShell + Microsoft.VisualBasic）
|
||
await invoke('quickpanel_delete_file', { path: f.path })
|
||
} catch (e) {
|
||
console.error('[quickpanel] 删除失败:', e)
|
||
}
|
||
},
|
||
},
|
||
],
|
||
deleteInfo: { path: f.path, isDir: f.isDir },
|
||
}
|
||
})
|
||
} catch (e) {
|
||
console.error('[quickpanel] 文件搜索失败:', e)
|
||
return []
|
||
}
|
||
}
|
||
}
|
||
|
||
/** 由设置页在索引构建完成后调用，启用 file Provider */
|
||
export function setFileIndexReady(ready: boolean) {
|
||
fileIndexReady = ready
|
||
}
|
||
|
||
// ===== clipboard Provider：复用剪贴板历史 =====
|
||
|
||
interface ClipboardSearchItem {
|
||
id: number
|
||
kind: string
|
||
preview: string
|
||
createdAt: number
|
||
}
|
||
|
||
class ClipboardProvider implements QPProvider {
|
||
id = 'clipboard'
|
||
label = '剪贴板'
|
||
priority = 70
|
||
|
||
async search(query: string): Promise<QPItem[]> {
|
||
if (!query.trim() || query.trim().length < 2) return []
|
||
try {
|
||
const items = await invoke<ClipboardSearchItem[]>('clipboard_search', {
|
||
query: query.trim(),
|
||
limit: 8,
|
||
offset: 0,
|
||
})
|
||
return items.map((c) => ({
|
||
id: `clip-${c.id}`,
|
||
title: c.preview.slice(0, 80),
|
||
subtitle: `${c.kind === 'text' ? '文本' : c.kind === 'image' ? '图片' : '文件'}`,
|
||
group: '剪贴板',
|
||
score: 0.5,
|
||
action: async () => {
|
||
try {
|
||
await invoke('clipboard_copy_back', { id: c.id })
|
||
} catch (e) {
|
||
console.error('[quickpanel] 复制失败:', e)
|
||
}
|
||
},
|
||
}))
|
||
} catch {
|
||
// 剪贴板模块可能未启用，静默忽略
|
||
return []
|
||
}
|
||
}
|
||
}
|
||
|
||
// ===== customCommand Provider：用户自定义命令 =====
|
||
|
||
interface CustomCommandConfig {
|
||
id: string
|
||
title: string
|
||
command: string
|
||
args: string[]
|
||
}
|
||
|
||
let customCommandsCache: CustomCommandConfig[] | null = null
|
||
|
||
async function loadCustomCommands(): Promise<CustomCommandConfig[]> {
|
||
if (customCommandsCache) return customCommandsCache
|
||
try {
|
||
const s = await invoke<{ customCommands: CustomCommandConfig[] }>('quickpanel_get_settings')
|
||
customCommandsCache = s.customCommands || []
|
||
return customCommandsCache
|
||
} catch {
|
||
return []
|
||
}
|
||
}
|
||
|
||
/** 设置页保存后调用，清除缓存使下次搜索重新加载 */
|
||
export function invalidateCustomCommandsCache() {
|
||
customCommandsCache = null
|
||
}
|
||
|
||
class CustomCommandProvider implements QPProvider {
|
||
id = 'custom'
|
||
label = '自定义'
|
||
priority = 92
|
||
|
||
async search(query: string): Promise<QPItem[]> {
|
||
const commands = await loadCustomCommands()
|
||
if (!query.trim()) return []
|
||
const results: Array<{ item: QPItem; score: number }> = []
|
||
for (const cmd of commands) {
|
||
const forms = buildItemForms(cmd.title)
|
||
const score = bestScore(query, forms)
|
||
if (score >= 0) {
|
||
results.push({
|
||
item: {
|
||
id: `custom-${cmd.id}`,
|
||
title: cmd.title,
|
||
subtitle: cmd.command,
|
||
group: '自定义',
|
||
action: async () => {
|
||
try {
|
||
await invoke('quickpanel_run_custom_command', {
|
||
command: cmd.command,
|
||
args: cmd.args,
|
||
})
|
||
} catch (e) {
|
||
console.error('[quickpanel] 自定义命令执行失败:', e)
|
||
}
|
||
},
|
||
},
|
||
score,
|
||
})
|
||
}
|
||
}
|
||
results.sort((a, b) => b.score - a.score)
|
||
return results.map(r => ({ ...r.item, score: r.score }))
|
||
}
|
||
}
|
||
|
||
// ===== history Provider：最近交互记录 =====
|
||
|
||
interface HistoryEntry {
|
||
id: string
|
||
title: string
|
||
subtitle?: string
|
||
group: string
|
||
iconPath?: string
|
||
/** 记录时的查询文本，用于点击历史项时重新搜索恢复 action */
|
||
query: string
|
||
timestamp: number
|
||
}
|
||
|
||
const HISTORY_ITEMS_KEY = 'thing_quickpanel_history_items'
|
||
const HISTORY_MAX = 50
|
||
|
||
/** 空查询时默认展示的历史条数（置顶部分） */
|
||
export const HISTORY_PREVIEW_COUNT = 3
|
||
|
||
function loadHistoryEntries(): HistoryEntry[] {
|
||
try {
|
||
const raw = localStorage.getItem(HISTORY_ITEMS_KEY)
|
||
if (!raw) return []
|
||
return JSON.parse(raw) as HistoryEntry[]
|
||
} catch {
|
||
return []
|
||
}
|
||
}
|
||
|
||
function saveHistoryEntries(entries: HistoryEntry[]) {
|
||
localStorage.setItem(HISTORY_ITEMS_KEY, JSON.stringify(entries.slice(0, HISTORY_MAX)))
|
||
}
|
||
|
||
/** 将一条历史记录转换为可执行的 QPItem */
|
||
function buildHistoryItem(e: HistoryEntry): QPItem {
|
||
return {
|
||
id: `history-${e.id}`,
|
||
title: e.title,
|
||
subtitle: e.subtitle,
|
||
group: '历史',
|
||
iconPath: e.iconPath,
|
||
historyQuery: e.query,
|
||
action: async () => {
|
||
// 重新搜索恢复 action 并执行
|
||
try {
|
||
const results = await aggregateSearch(e.query)
|
||
// 按 id 精确匹配原 item
|
||
const target = results.find(r => r.id === e.id) ?? results.find(r => r.title === e.title)
|
||
if (target) {
|
||
await target.action()
|
||
}
|
||
} catch (err) {
|
||
console.error('[quickpanel] 历史项执行失败:', err)
|
||
}
|
||
},
|
||
}
|
||
}
|
||
|
||
/** 记录一次交互。在 QuickPanel.vue 执行 item 时调用。
|
||
* query 为执行时的搜索文本（用于后续重建 action）。 */
|
||
export function recordHistoryItem(item: QPItem, query: string) {
|
||
if (!item.id || item.group === '历史') return // 历史项自身不重复记录
|
||
const entries = loadHistoryEntries()
|
||
// 去重：同 id 移除旧的，插到头部
|
||
const filtered = entries.filter(e => e.id !== item.id)
|
||
filtered.unshift({
|
||
id: item.id,
|
||
title: item.title,
|
||
subtitle: item.subtitle,
|
||
group: item.group,
|
||
iconPath: item.iconPath,
|
||
query: query || item.title,
|
||
timestamp: Date.now(),
|
||
})
|
||
saveHistoryEntries(filtered.slice(0, HISTORY_MAX))
|
||
}
|
||
|
||
/** 清空历史记录 */
|
||
export function clearHistory() {
|
||
localStorage.removeItem(HISTORY_ITEMS_KEY)
|
||
}
|
||
|
||
/** 获取置顶的历史项（最近 N 条），用于空查询时在结果列表顶部显示 */
|
||
export function getTopHistoryItems(): QPItem[] {
|
||
const entries = loadHistoryEntries()
|
||
return entries.slice(0, HISTORY_PREVIEW_COUNT).map(buildHistoryItem)
|
||
}
|
||
|
||
/** 获取置顶历史之后的剩余历史项，用于 Accordion 折叠显示 */
|
||
export function getMoreHistoryItems(): QPItem[] {
|
||
const entries = loadHistoryEntries()
|
||
return entries.slice(HISTORY_PREVIEW_COUNT).map(buildHistoryItem)
|
||
}
|
||
|
||
/** 获取剩余历史数量（用于 Accordion 标题显示） */
|
||
export function getMoreHistoryCount(): number {
|
||
const entries = loadHistoryEntries()
|
||
return Math.max(0, entries.length - HISTORY_PREVIEW_COUNT)
|
||
}
|
||
|
||
class HistoryProvider implements QPProvider {
|
||
id = 'history'
|
||
label = '历史'
|
||
priority = 99 // 最高优先级，空查询时显示在最前
|
||
|
||
async search(query: string): Promise<QPItem[]> {
|
||
if (query.trim()) return [] // 历史只在空查询时显示
|
||
// 只返回置顶3条，剩余由 Accordion 承载
|
||
return getTopHistoryItems()
|
||
}
|
||
}
|
||
|
||
// ===== special Provider：Windows 常用快捷位置 =====
|
||
|
||
interface SpecialLocation {
|
||
id: string
|
||
title: string
|
||
subtitle: string
|
||
keywords: string[]
|
||
/** file: 真实路径；shell: explorer 打开的 shell 路径；cmd: 可执行命令 */
|
||
kind: 'file' | 'shell' | 'cmd'
|
||
target: string
|
||
args: string[]
|
||
}
|
||
|
||
let specialCache: SpecialLocation[] | null = null
|
||
let specialCacheTime = 0
|
||
const SPECIAL_CACHE_TTL = 60_000 // 1 分钟缓存
|
||
|
||
async function loadSpecials(): Promise<SpecialLocation[]> {
|
||
if (specialCache && Date.now() - specialCacheTime < SPECIAL_CACHE_TTL) {
|
||
return specialCache
|
||
}
|
||
try {
|
||
const list = await invoke<SpecialLocation[]>('quickpanel_get_special_locations')
|
||
specialCache = list
|
||
specialCacheTime = Date.now()
|
||
return list
|
||
} catch (e) {
|
||
console.error('[quickpanel] 获取快捷位置失败:', e)
|
||
return []
|
||
}
|
||
}
|
||
|
||
class SpecialProvider implements QPProvider {
|
||
id = 'special'
|
||
label = '快捷'
|
||
priority = 60
|
||
|
||
async search(query: string): Promise<QPItem[]> {
|
||
const list = await loadSpecials()
|
||
if (!list.length) return []
|
||
if (!query.trim()) return [] // 空查询不占用列表，由用户主动搜索
|
||
|
||
const open = async (s: SpecialLocation) => {
|
||
try {
|
||
await invoke('quickpanel_open_special', {
|
||
kind: s.kind,
|
||
target: s.target,
|
||
args: s.args,
|
||
})
|
||
} catch (e) {
|
||
console.error('[quickpanel] 打开快捷位置失败:', e)
|
||
}
|
||
}
|
||
|
||
const items: QPItem[] = list.map(s => ({
|
||
id: `sp-${s.id}`,
|
||
title: s.title,
|
||
subtitle: s.subtitle,
|
||
group: '快捷',
|
||
action: () => open(s),
|
||
subActions:
|
||
s.kind === 'file'
|
||
? [
|
||
{ id: 'open', label: '打开', action: () => open(s) },
|
||
{
|
||
id: 'reveal',
|
||
label: '在资源管理器中显示',
|
||
action: async () => {
|
||
try {
|
||
await invoke('quickpanel_reveal_in_explorer', { path: s.target })
|
||
} catch (e) {
|
||
console.error('[quickpanel] 资源管理器显示失败:', e)
|
||
}
|
||
},
|
||
},
|
||
{
|
||
id: 'copy-path',
|
||
label: '复制路径',
|
||
action: async () => {
|
||
try {
|
||
await navigator.clipboard.writeText(s.target)
|
||
} catch {
|
||
/* 忽略 */
|
||
}
|
||
},
|
||
},
|
||
]
|
||
: undefined,
|
||
}))
|
||
|
||
const scored: Array<{ item: QPItem; score: number }> = []
|
||
items.forEach((item, idx) => {
|
||
const forms = buildItemForms(item.title, list[idx].keywords)
|
||
const score = bestScore(query, forms)
|
||
if (score >= 0) scored.push({ item, score })
|
||
})
|
||
scored.sort((a, b) => b.score - a.score)
|
||
return scored.slice(0, 8).map(s => ({ ...s.item, score: s.score }))
|
||
}
|
||
}
|
||
|
||
// ===== unit Provider：单位 / 货币 / 时间 / 温度换算 =====
|
||
|
||
interface UnitDef {
|
||
/** 可匹配的符号（含中文），小写优先；带 exactCase 的单位只做精确大小写匹配 */
|
||
symbols: string[]
|
||
label: string
|
||
/** 与基准单位的换算系数（基准单位 = 1） */
|
||
factor: number
|
||
/** 仅精确大小写匹配（如小写 m = 米，避免与 MB 混淆） */
|
||
exactCase?: boolean
|
||
}
|
||
|
||
interface UnitCategory {
|
||
id: string
|
||
name: string
|
||
units: UnitDef[]
|
||
}
|
||
|
||
const UNIT_CATEGORIES: UnitCategory[] = [
|
||
{
|
||
id: 'length',
|
||
name: '长度',
|
||
units: [
|
||
{ symbols: ['m', 'meter', 'meters', '米', '公尺'], label: '米', factor: 1, exactCase: true },
|
||
{ symbols: ['km', 'kilometer', 'kilometers', '千米', '公里'], label: '千米', factor: 1000 },
|
||
{ symbols: ['cm', 'centimeter', 'centimeters', '厘米'], label: '厘米', factor: 0.01 },
|
||
{ symbols: ['mm', 'millimeter', 'millimeters', '毫米'], label: '毫米', factor: 0.001 },
|
||
{ symbols: ['in', 'inch', 'inches', '英寸'], label: '英寸', factor: 0.0254 },
|
||
{ symbols: ['ft', 'foot', 'feet', '英尺'], label: '英尺', factor: 0.3048 },
|
||
{ symbols: ['yd', 'yard', 'yards', '码'], label: '码', factor: 0.9144 },
|
||
{ symbols: ['mi', 'mile', 'miles', '英里'], label: '英里', factor: 1609.344 },
|
||
{ symbols: ['里', 'li'], label: '里', factor: 500 },
|
||
],
|
||
},
|
||
{
|
||
id: 'data',
|
||
name: '数据',
|
||
units: [
|
||
{ symbols: ['b', 'byte', 'bytes', '字节'], label: '字节', factor: 1 },
|
||
{ symbols: ['kb', 'kib', 'kilobyte', 'kilobytes', '千字节'], label: 'KB', factor: 1024 },
|
||
{ symbols: ['mb', 'mib', 'megabyte', 'megabytes', '兆字节'], label: 'MB', factor: 1024 ** 2 },
|
||
{ symbols: ['gb', 'gib', 'gigabyte', 'gigabytes', '吉字节'], label: 'GB', factor: 1024 ** 3 },
|
||
{ symbols: ['tb', 'tib', 'terabyte', 'terabytes', '太字节'], label: 'TB', factor: 1024 ** 4 },
|
||
{ symbols: ['bit', 'bits', '比特'], label: 'bit', factor: 1 / 8 },
|
||
],
|
||
},
|
||
{
|
||
id: 'speed',
|
||
name: '网速',
|
||
units: [
|
||
{ symbols: ['bps', '比特/秒'], label: 'bps', factor: 1 },
|
||
{ symbols: ['kbps', '千比特/秒'], label: 'Kbps', factor: 1024 },
|
||
{ symbols: ['mbps', '兆比特/秒'], label: 'Mbps', factor: 1024 ** 2 },
|
||
{ symbols: ['gbps', '吉比特/秒'], label: 'Gbps', factor: 1024 ** 3 },
|
||
{ symbols: ['b/s'], label: 'B/s', factor: 8 },
|
||
{ symbols: ['kb/s'], label: 'KB/s', factor: 8 * 1024 },
|
||
{ symbols: ['mb/s'], label: 'MB/s', factor: 8 * 1024 ** 2 },
|
||
{ symbols: ['gb/s'], label: 'GB/s', factor: 8 * 1024 ** 3 },
|
||
],
|
||
},
|
||
{
|
||
id: 'time',
|
||
name: '时间',
|
||
units: [
|
||
{ symbols: ['s', 'sec', 'secs', 'second', 'seconds', '秒'], label: '秒', factor: 1 },
|
||
{ symbols: ['min', 'mins', 'minute', 'minutes', '分钟', '分'], label: '分钟', factor: 60 },
|
||
{ symbols: ['h', 'hr', 'hrs', 'hour', 'hours', '小时', '时'], label: '小时', factor: 3600 },
|
||
{ symbols: ['day', 'days', '天', '日'], label: '天', factor: 86400 },
|
||
{ symbols: ['week', 'weeks', '周', '星期'], label: '周', factor: 604800 },
|
||
{ symbols: ['year', 'years', '年'], label: '年', factor: 31536000 },
|
||
],
|
||
},
|
||
{
|
||
id: 'weight',
|
||
name: '重量',
|
||
units: [
|
||
{ symbols: ['kg', '千克', '公斤'], label: '千克', factor: 1 },
|
||
{ symbols: ['g', 'gram', 'grams', '克'], label: '克', factor: 0.001 },
|
||
{ symbols: ['mg', 'milligram', '毫克'], label: '毫克', factor: 1e-6 },
|
||
{ symbols: ['t', 'ton', 'tons', '吨'], label: '吨', factor: 1000 },
|
||
{ symbols: ['lb', 'lbs', 'pound', 'pounds', '磅'], label: '磅', factor: 0.45359237 },
|
||
{ symbols: ['oz', 'ounce', 'ounces', '盎司'], label: '盎司', factor: 0.028349523125 },
|
||
{ symbols: ['斤', 'jin'], label: '斤', factor: 0.5 },
|
||
{ symbols: ['两', 'liang'], label: '两', factor: 0.05 },
|
||
],
|
||
},
|
||
]
|
||
|
||
// ===== 货币换算（汇率动态获取，带本地缓存与兜底值） =====
|
||
|
||
const DEFAULT_CURRENCY_RATES: Record<string, number> = {
|
||
usd: 1,
|
||
cny: 7.2,
|
||
eur: 0.92,
|
||
gbp: 0.78,
|
||
jpy: 156,
|
||
hkd: 7.8,
|
||
}
|
||
const CURRENCY_CACHE_KEY = 'thing_quickpanel_currency_rates'
|
||
|
||
function getCurrencyRates(): Record<string, number> {
|
||
try {
|
||
const raw = localStorage.getItem(CURRENCY_CACHE_KEY)
|
||
if (raw) {
|
||
const p = JSON.parse(raw)
|
||
if (p?.rates && Date.now() - p.ts < 24 * 3600 * 1000) return p.rates
|
||
}
|
||
} catch {
|
||
/* 忽略损坏缓存 */
|
||
}
|
||
return DEFAULT_CURRENCY_RATES
|
||
}
|
||
|
||
let currencyRefreshing = false
|
||
/** 后台刷新汇率（失败静默，继续用缓存/兜底值），结果写入 localStorage 供下次使用 */
|
||
async function refreshCurrencyRates() {
|
||
if (currencyRefreshing) return
|
||
currencyRefreshing = true
|
||
try {
|
||
const res = await fetch('https://open.er-api.com/v6/latest/USD')
|
||
const data = await res.json()
|
||
if (data?.result === 'success' && data.rates) {
|
||
const r = data.rates as Record<string, number | undefined>
|
||
const rates: Record<string, number> = {
|
||
usd: 1,
|
||
cny: r.CNY ?? DEFAULT_CURRENCY_RATES.cny,
|
||
eur: r.EUR ?? DEFAULT_CURRENCY_RATES.eur,
|
||
gbp: r.GBP ?? DEFAULT_CURRENCY_RATES.gbp,
|
||
jpy: r.JPY ?? DEFAULT_CURRENCY_RATES.jpy,
|
||
hkd: r.HKD ?? DEFAULT_CURRENCY_RATES.hkd,
|
||
}
|
||
localStorage.setItem(CURRENCY_CACHE_KEY, JSON.stringify({ ts: Date.now(), rates }))
|
||
}
|
||
} catch {
|
||
/* 网络失败，继续使用默认/缓存汇率 */
|
||
} finally {
|
||
currencyRefreshing = false
|
||
}
|
||
}
|
||
|
||
/** 动态构建货币类别（基准 = 美元；factor 为「1 单位该货币 = ? 美元」） */
|
||
function getCurrencyCategory(): UnitCategory {
|
||
const r = getCurrencyRates()
|
||
const perUsd = (v: number) => (v > 0 ? 1 / v : 0)
|
||
return {
|
||
id: 'currency',
|
||
name: '货币',
|
||
units: [
|
||
{ symbols: ['$', 'usd', '美元', '美金', '美刀'], label: '美元', factor: 1 },
|
||
{ symbols: ['¥', '￥', 'rmb', 'cny', '元', '人民币'], label: '人民币', factor: perUsd(r.cny) },
|
||
{ symbols: ['€', 'eur', '欧元'], label: '欧元', factor: perUsd(r.eur) },
|
||
{ symbols: ['£', 'gbp', '英镑'], label: '英镑', factor: perUsd(r.gbp) },
|
||
{ symbols: ['jpy', '日元', '日圆'], label: '日元', factor: perUsd(r.jpy) },
|
||
{ symbols: ['hkd', '港币', '港元'], label: '港元', factor: perUsd(r.hkd) },
|
||
],
|
||
}
|
||
}
|
||
|
||
/** 温度匹配（仿射换算，单独处理） */
|
||
function matchTemperature(token: string): 'C' | 'F' | 'K' | null {
|
||
const t = token.toLowerCase().replace(/°/g, '')
|
||
if (['c', 'celsius', '摄氏度', '摄氏'].includes(t)) return 'C'
|
||
if (['f', 'fahrenheit', '华氏度', '华氏'].includes(t)) return 'F'
|
||
if (['kelvin', '开尔文'].includes(t)) return 'K'
|
||
return null
|
||
}
|
||
|
||
/** 在（普通 + 货币）类别中匹配单位 token */
|
||
function matchUnit(
|
||
token: string,
|
||
categories: UnitCategory[],
|
||
): { cat: UnitCategory; unit: UnitDef } | null {
|
||
// 第一轮：精确大小写匹配
|
||
for (const cat of categories) {
|
||
for (const unit of cat.units) {
|
||
if (unit.symbols.some(s => s === token)) return { cat, unit }
|
||
}
|
||
}
|
||
// 第二轮：大小写不敏感；exactCase 单位（如 m=米）跳过，避免 "1M" 误判为 1 米
|
||
const lower = token.toLowerCase()
|
||
for (const cat of categories) {
|
||
for (const unit of cat.units) {
|
||
if (unit.exactCase) continue
|
||
if (unit.symbols.some(s => s.toLowerCase() === lower)) return { cat, unit }
|
||
}
|
||
}
|
||
return null
|
||
}
|
||
|
||
/** 数值格式化（去掉多余的浮点尾巴） */
|
||
function formatUnitValue(v: number): string {
|
||
if (!isFinite(v)) return ''
|
||
if (v === 0) return '0'
|
||
const abs = Math.abs(v)
|
||
if (abs >= 1e12) return v.toExponential(2)
|
||
if (abs >= 1e6) return Number(v.toFixed(0)).toLocaleString('en-US')
|
||
if (abs >= 1000) return Number(v.toFixed(1)).toLocaleString('en-US')
|
||
if (abs >= 100) return Number(v.toFixed(1)).toString()
|
||
if (abs >= 1) return Number(v.toFixed(2)).toString()
|
||
if (abs >= 1e-4) return Number(v.toFixed(4)).toString()
|
||
return v.toExponential(2)
|
||
}
|
||
|
||
/** 结果展示优先级：整数 > 常见量级(1~1000) > 其他 */
|
||
function unitNiceRank(v: number): number {
|
||
if (Number.isInteger(v)) return 0
|
||
const abs = Math.abs(v)
|
||
if (abs >= 1 && abs < 1000) return 1
|
||
return 2
|
||
}
|
||
|
||
function buildUnitResultItem(
|
||
value: number,
|
||
fromLabel: string,
|
||
catName: string,
|
||
toLabel: string,
|
||
toValue: number,
|
||
idx: number,
|
||
): QPItem {
|
||
const text = `${formatUnitValue(toValue)} ${toLabel}`
|
||
return {
|
||
id: `unit-${catName}-${idx}`,
|
||
title: text,
|
||
subtitle: `${value} ${fromLabel}（${catName}换算）`,
|
||
group: '换算',
|
||
score: 0.85,
|
||
action: async () => {
|
||
try {
|
||
await navigator.clipboard.writeText(text)
|
||
} catch {
|
||
/* 忽略 */
|
||
}
|
||
},
|
||
}
|
||
}
|
||
|
||
class UnitProvider implements QPProvider {
|
||
id = 'unit'
|
||
label = '换算'
|
||
priority = 80
|
||
|
||
async search(query: string): Promise<QPItem[]> {
|
||
const trimmed = query.trim()
|
||
if (!trimmed) return []
|
||
const m = trimmed.match(/^(\d+(?:\.\d+)?)\s*(.+)$/)
|
||
if (!m) return []
|
||
const value = parseFloat(m[1])
|
||
if (!isFinite(value) || value <= 0) return []
|
||
const token = m[2].trim()
|
||
if (!token) return []
|
||
|
||
// 温度（仿射换算）
|
||
const tFrom = matchTemperature(token)
|
||
if (tFrom) {
|
||
const celsius =
|
||
tFrom === 'C' ? value : tFrom === 'F' ? ((value - 32) * 5) / 9 : value - 273.15
|
||
const convs: Array<{ label: string; v: number }> = [
|
||
{ label: '摄氏度', v: celsius },
|
||
{ label: '华氏度', v: (celsius * 9) / 5 + 32 },
|
||
{ label: '开尔文', v: celsius + 273.15 },
|
||
]
|
||
return convs
|
||
.filter(c => !(tFrom === 'C' && c.label === '摄氏度') && !(tFrom === 'F' && c.label === '华氏度') && !(tFrom === 'K' && c.label === '开尔文'))
|
||
.map((c, i) => buildUnitResultItem(value, `${tFrom}°`, '温度', c.label, c.v, i))
|
||
}
|
||
|
||
// 普通单位 / 货币
|
||
const currencyCat = getCurrencyCategory()
|
||
const categories = [...UNIT_CATEGORIES, currencyCat]
|
||
const matched = matchUnit(token, categories)
|
||
if (!matched) return []
|
||
const { cat, unit } = matched
|
||
if (cat.id === 'currency') {
|
||
// 命中货币：后台刷新一次汇率，不阻塞本次结果
|
||
void refreshCurrencyRates()
|
||
}
|
||
|
||
const base = value * unit.factor
|
||
const results: Array<{ item: QPItem; rank: number }> = []
|
||
for (const u of cat.units) {
|
||
if (u === unit) continue
|
||
const v = base / u.factor
|
||
results.push({
|
||
item: buildUnitResultItem(value, unit.label, cat.name, u.label, v, results.length),
|
||
rank: unitNiceRank(v),
|
||
})
|
||
}
|
||
results.sort((a, b) => a.rank - b.rank)
|
||
return results.slice(0, 8).map(r => r.item)
|
||
}
|
||
}
|
||
|
||
// ===== Provider 注册 =====
|
||
|
||
let providers: QPProvider[] | null = null
|
||
|
||
export function getProviders(): QPProvider[] {
|
||
if (!providers) {
|
||
providers = [
|
||
new HistoryProvider(),
|
||
new CommandProvider(),
|
||
new CustomCommandProvider(),
|
||
new AppProvider(),
|
||
new FileProvider(),
|
||
new ClipboardProvider(),
|
||
new CalcProvider(),
|
||
new UnitProvider(),
|
||
new SpecialProvider(),
|
||
new SystemProvider(),
|
||
new WebProvider(),
|
||
]
|
||
}
|
||
return providers
|
||
}
|
||
|
||
/**
|
||
* 聚合搜索：并行调用各 Provider，合并结果，按 score 降序排序。
|
||
* 空查询时返回 command Provider 的快捷入口 + system Provider 的固定项。
|
||
*/
|
||
export async function aggregateSearch(query: string): Promise<QPItem[]> {
|
||
const all = getProviders()
|
||
const results = await Promise.all(all.map(p => Promise.resolve(p.search(query))))
|
||
const merged: QPItem[] = []
|
||
results.forEach((items, idx) => {
|
||
items.forEach(item => {
|
||
// 未打分的项赋予基础分（按 provider 优先级递减）
|
||
if (item.score === undefined) {
|
||
item.score = (10 - idx) * 0.01
|
||
}
|
||
merged.push(item)
|
||
})
|
||
})
|
||
|
||
// 去重：所有来源的「应用」（含文件索引中的 .lnk）按名称归并，保留可靠性最高的来源
|
||
// 可靠性：开始菜单(appRank 0) > 桌面(1) > 其他位置(2)；同可靠性时保留分数更高的
|
||
// （如 "TRAE Work CN" 在开始菜单 + 桌面 + 某索引目录都有 .lnk，只留开始菜单那条）
|
||
const appKey = (title: string): string => {
|
||
let t = title.trim().toLowerCase()
|
||
if (t.endsWith('.lnk')) t = t.slice(0, -4).trim()
|
||
return t
|
||
}
|
||
// 应用候选：应用分组，以及文件分组中的 .lnk 快捷方式
|
||
const isAppLike = (item: QPItem): boolean => {
|
||
if (item.group === '应用') return true
|
||
if (item.group === '文件' && item.title && item.title.toLowerCase().endsWith('.lnk')) return true
|
||
return false
|
||
}
|
||
const bestAppByKey = new Map<string, QPItem>()
|
||
for (const item of merged) {
|
||
if (!isAppLike(item) || !item.title) continue
|
||
const key = appKey(item.title)
|
||
const prev = bestAppByKey.get(key)
|
||
if (!prev) {
|
||
bestAppByKey.set(key, item)
|
||
continue
|
||
}
|
||
// 比较可靠性：appRank 越小越可靠；文件分组 .lnk 无 appRank 时按路径推断
|
||
const rankOf = (i: QPItem): number => {
|
||
if (i.appRank !== undefined) return i.appRank
|
||
if (i.group === '文件') return appRankFromPath(i.subtitle ?? '')
|
||
return 2
|
||
}
|
||
const rankA = rankOf(item)
|
||
const rankB = rankOf(prev)
|
||
if (rankA < rankB || (rankA === rankB && (item.score ?? 0) > (prev.score ?? 0))) {
|
||
bestAppByKey.set(key, item)
|
||
}
|
||
}
|
||
const keptAppIds = new Set(Array.from(bestAppByKey.values()).map(i => i.id))
|
||
const deduped = merged.filter(item => {
|
||
if (!isAppLike(item)) return true
|
||
return keptAppIds.has(item.id)
|
||
})
|
||
|
||
deduped.sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
|
||
return deduped
|
||
}
|