feat(analyze): implement project analysis in worker with progress reporting

Author: MidnightCrowing

electron/ipc/project.ts

@@ -1,30 +1,61 @@
 import { exec } from 'node:child_process'
 import path from 'node:path'
+import { Worker } from 'node:worker_threads'
 
 import { dialog, ipcMain } from 'electron'
 import fs from 'fs-extra'
 import trash from 'trash'
 
 import { projectsFilePath } from '../utils/dataPath'
 import type { LinguistResult } from '../utils/linguist'
-import { analyzeFolder } from '../utils/linguist'
 
 // 传入项目根目录，获取项目各编程语言的占比
-ipcMain.handle('project:analyze', async (_, folderPath): Promise<LinguistResult | { error: string }> => {
-  try {
-    const stat = await fs.stat(folderPath)
+ipcMain.handle('project:analyze', async (event, folderPath): Promise<LinguistResult | { error: string }> => {
+  return await new Promise((resolve) => {
+    try {
+      const workerUrl = new URL('../workers/linguistAnalyze.worker.js', import.meta.url)
+      const worker = new Worker(workerUrl, { type: 'module', workerData: { folderPath } } as any)
+
+      const cleanup = () => worker.removeAllListeners()
+      const send = (stage: 'start' | 'checking' | 'analyzing' | 'done') => {
+        try {
+          event.sender.send('project:analyze:progress', {
+            folderPath,
+            stage,
+          })
+        }
+        catch {}
+      }
 
-    // 检查是否是目录
-    if (!stat.isDirectory()) {
-      return { error: 'Provided path is not a directory' }
+      worker.on('message', (msg: any) => {
+        if (msg?.type === 'progress') {
+          send(msg.stage)
+        }
+        else if (msg?.type === 'result') {
+          cleanup()
+          resolve(msg.result as LinguistResult)
+        }
+        else if (msg?.type === 'error') {
+          cleanup()
+          resolve({ error: msg.error || 'analyze error' })
+        }
+      })
+
+      worker.once('error', (err) => {
+        cleanup()
+        resolve({ error: String(err) })
+      })
+      worker.once('exit', (code) => {
+        if (code !== 0) {
+          cleanup()
+          resolve({ error: `analyze worker exited with code ${code}` })
+        }
+      })
     }
-
-    // 如果路径是有效的目录，继续分析
-    return analyzeFolder(folderPath)
-  }
-  catch (error) {
-    return { error: `Error checking folder path:${error}` }
-  }
+    catch (e) {
+      resolve({ error: `Error starting analyze worker: ${String(e)}` })
+    }
+  })
 })
 
 // 使用IDE打开项目

electron/ipc/scanner.ts

@@ -21,7 +21,7 @@ ipcMain.handle('scanner:scan', async (_event, payload: ScanPayload): Promise<Sca
   return new Promise((resolve, reject) => {
     try {
       const workerUrl = new URL('../workers/projectScanner.worker.js', import.meta.url)
-      const worker = new Worker(workerUrl, { type: 'module', workerData: payload })
+      const worker = new Worker(workerUrl, { type: 'module', workerData: payload } as any)
 
       const items: ScanResultItem[] = []
       const cleanup = () => worker.removeAllListeners()
@@ -62,7 +62,7 @@ let nextSessionId = 1
 ipcMain.handle('scanner:start', (event, payload: ScanPayload): { sessionId: number } => {
   const sessionId = nextSessionId++
   const workerUrl = new URL('../workers/projectScanner.worker.js', import.meta.url)
-  const worker = new Worker(workerUrl, { type: 'module', workerData: payload })
+  const worker = new Worker(workerUrl, { type: 'module', workerData: payload } as any)
 
   sessions.set(sessionId, worker)
 

electron/preload.ts

@@ -14,6 +14,11 @@ contextBridge.exposeInMainWorld('api', {
 
   // project
   analyzeProject: (folderPath: string) => ipcRenderer.invoke('project:analyze', folderPath),
+  onProjectAnalyzeProgress: (cb: (data: { folderPath: string, stage: 'start' | 'checking' | 'analyzing' | 'done' }) => void) => {
+    const handler = (_: any, data: any) => cb(data)
+    ipcRenderer.on('project:analyze:progress', handler)
+    return () => ipcRenderer.removeListener('project:analyze:progress', handler)
+  },
   openProject: (idePath: string, projectPath: string) => ipcRenderer.invoke('project:open', idePath, projectPath),
   deleteProject: (projectPath: string) => ipcRenderer.invoke('project:delete', projectPath),
   importProject: () => ipcRenderer.invoke('project:import'),

electron/workers/linguistAnalyze.worker.ts

@@ -0,0 +1,37 @@
+import * as fs from 'node:fs/promises'
+import { parentPort, workerData } from 'node:worker_threads'
+
+import type { LinguistResult } from '../utils/linguist'
+import { analyzeFolder } from '../utils/linguist'
+
+interface Payload { folderPath: string }
+
+type WorkerMsg
+  = | { type: 'progress', stage: 'start' | 'checking' | 'analyzing' | 'done' }
+    | { type: 'result', result: LinguistResult }
+    | { type: 'error', error: string }
+
+async function run() {
+  const { folderPath } = workerData as Payload
+
+  try {
+    parentPort?.postMessage({ type: 'progress', stage: 'start' } satisfies WorkerMsg)
+
+    // 轻量校验，避免主线程重复 IO
+    parentPort?.postMessage({ type: 'progress', stage: 'checking' } satisfies WorkerMsg)
+    const stat = await fs.stat(folderPath)
+    if (!stat.isDirectory())
+      throw new Error('Provided path is not a directory')
+
+    parentPort?.postMessage({ type: 'progress', stage: 'analyzing' } satisfies WorkerMsg)
+    const result = await analyzeFolder(folderPath)
+
+    parentPort?.postMessage({ type: 'result', result } satisfies WorkerMsg)
+    parentPort?.postMessage({ type: 'progress', stage: 'done' } satisfies WorkerMsg)
+  }
+  catch (e: any) {
+    parentPort?.postMessage({ type: 'error', error: e?.message || String(e) } satisfies WorkerMsg)
+  }
+}
+
+run()

src/global.d.ts

@@ -17,6 +17,7 @@ declare global {
 
       // project
       analyzeProject: (folderPath: string) => Promise<LinguistResult | { error: string }>
+      onProjectAnalyzeProgress: (cb: (data: { folderPath: string, stage: 'start' | 'checking' | 'analyzing' | 'done' }) => void) => () => void
       openProject: (idePath: string, projectPath: string) => Promise<string>
       deleteProject: (projectPath: string) => Promise<boolean>
       importProject: () => Promise<boolean>

src/services/languageAnalyzer.ts

@@ -2,7 +2,7 @@ import type { JeDropdownOptionGroupProps, JeDropdownOptionProps } from 'jetv-ui'
 
 import type { languagesGroupItem } from '~/constants/localProject'
 import { t } from '~/utils/i18n'
-import type { LinguistLanguageResult, LinguistResult } from '~/views/ProjectConfig/types'
+import type { LinguistLanguageResult } from '~/views/ProjectConfig/types'
 
 /**
  * 用于分析项目语言的工具类
@@ -64,8 +64,10 @@ export class LanguageAnalyzer {
    * @returns {Promise<Record<string, LinguistLanguageResult>>} - 语言分析结果
    */
   private async getLanguagesResult(): Promise<Record<string, LinguistLanguageResult>> {
-    const { languages } = await window.api.analyzeProject(this.folderPath) as { languages: LinguistResult['languages'] }
-    return languages.results
+    const res = await window.api.analyzeProject(this.folderPath) as any
+    if (!res || 'error' in res || !res.languages)
+      return {}
+    return res.languages.results as Record<string, LinguistLanguageResult>
   }
 
   /**