refactor: simplify window.api definition (#5412)

* refactor(preload): remove unused index.d.ts file and export WindowApiType from index.ts

* fix: type def errors in original index.ts file

src/preload/index.d.ts

@@ -1,213 +0,0 @@
-import { ExtractChunkData } from '@cherrystudio/embedjs-interfaces'
-import { ElectronAPI } from '@electron-toolkit/preload'
-import type { File } from '@google/genai'
-import type { GetMCPPromptResponse, MCPPrompt, MCPResource, MCPServer, MCPTool } from '@renderer/types'
-import { AppInfo, FileType, KnowledgeBaseParams, KnowledgeItem, LanguageVarious, WebDavConfig } from '@renderer/types'
-import type { LoaderReturn } from '@shared/config/types'
-import type { OpenDialogOptions } from 'electron'
-import type { UpdateInfo } from 'electron-updater'
-
-interface BackupFile {
-  fileName: string
-  modifiedTime: string
-  size: number
-}
-
-declare global {
-  interface Window {
-    electron: ElectronAPI
-    api: {
-      getAppInfo: () => Promise<AppInfo>
-      checkForUpdate: () => Promise<{ currentVersion: string; updateInfo: UpdateInfo | null }>
-      showUpdateDialog: () => Promise<void>
-      openWebsite: (url: string) => void
-      setProxy: (proxy: string | undefined) => void
-      setLanguage: (theme: LanguageVarious) => void
-      setLaunchOnBoot: (isActive: boolean) => void
-      setLaunchToTray: (isActive: boolean) => void
-      setTray: (isActive: boolean) => void
-      setTrayOnClose: (isActive: boolean) => void
-      restartTray: () => void
-      setTheme: (theme: 'light' | 'dark' | 'auto') => void
-      getTheme: () => Promise<'light' | 'dark' | 'auto'>
-      setCustomCss: (css: string) => void
-      setAutoUpdate: (isActive: boolean) => void
-      reload: () => void
-      clearCache: () => Promise<{ success: boolean; error?: string }>
-      system: {
-        getDeviceType: () => Promise<'mac' | 'windows' | 'linux'>
-        getHostname: () => Promise<string>
-      }
-      zip: {
-        compress: (text: string) => Promise<Buffer>
-        decompress: (text: Buffer) => Promise<string>
-      }
-      backup: {
-        backup: (fileName: string, data: string, destinationPath?: string) => Promise<Readable>
-        restore: (backupPath: string) => Promise<string>
-        backupToWebdav: (data: string, webdavConfig: WebDavConfig) => Promise<boolean>
-        restoreFromWebdav: (webdavConfig: WebDavConfig) => Promise<string>
-        listWebdavFiles: (webdavConfig: WebDavConfig) => Promise<BackupFile[]>
-        checkConnection: (webdavConfig: WebDavConfig) => Promise<boolean>
-        createDirectory: (webdavConfig: WebDavConfig, path: string, options?: CreateDirectoryOptions) => Promise<void>
-        deleteWebdavFile: (fileName: string, webdavConfig: WebDavConfig) => Promise<boolean>
-      }
-      file: {
-        select: (options?: OpenDialogOptions) => Promise<FileType[] | null>
-        upload: (file: FileType) => Promise<FileType>
-        delete: (fileId: string) => Promise<void>
-        read: (fileId: string) => Promise<string>
-        clear: () => Promise<void>
-        get: (filePath: string) => Promise<FileType | null>
-        selectFolder: () => Promise<string | null>
-        create: (fileName: string) => Promise<string>
-        write: (filePath: string, data: Uint8Array | string) => Promise<void>
-        open: (options?: OpenDialogOptions) => Promise<{ fileName: string; filePath: string; content: Buffer } | null>
-        openPath: (path: string) => Promise<void>
-        save: (
-          path: string,
-          content: string | NodeJS.ArrayBufferView,
-          options?: SaveDialogOptions
-        ) => Promise<string | null>
-        saveImage: (name: string, data: string) => void
-        base64Image: (fileId: string) => Promise<{ mime: string; base64: string; data: string }>
-        download: (url: string) => Promise<FileType | null>
-        copy: (fileId: string, destPath: string) => Promise<void>
-        binaryFile: (fileId: string) => Promise<{ data: Buffer; mime: string }>
-      }
-      fs: {
-        read: (path: string) => Promise<string>
-      }
-      export: {
-        toWord: (markdown: string, fileName: string) => Promise<void>
-      }
-      openPath: (path: string) => Promise<void>
-      shortcuts: {
-        update: (shortcuts: Shortcut[]) => Promise<void>
-      }
-      knowledgeBase: {
-        create: (base: KnowledgeBaseParams) => Promise<void>
-        reset: (base: KnowledgeBaseParams) => Promise<void>
-        delete: (id: string) => Promise<void>
-        add: ({
-          base,
-          item,
-          forceReload = false
-        }: {
-          base: KnowledgeBaseParams
-          item: KnowledgeItem
-          forceReload?: boolean
-        }) => Promise<LoaderReturn>
-        remove: ({
-          uniqueId,
-          uniqueIds,
-          base
-        }: {
-          uniqueId: string
-          uniqueIds: string[]
-          base: KnowledgeBaseParams
-        }) => Promise<void>
-        search: ({ search, base }: { search: string; base: KnowledgeBaseParams }) => Promise<ExtractChunkData[]>
-        rerank: ({
-          search,
-          base,
-          results
-        }: {
-          search: string
-          base: KnowledgeBaseParams
-          results: ExtractChunkData[]
-        }) => Promise<ExtractChunkData[]>
-      }
-      window: {
-        setMinimumSize: (width: number, height: number) => Promise<void>
-        resetMinimumSize: () => Promise<void>
-      }
-      gemini: {
-        uploadFile: (file: FileType, apiKey: string) => Promise<File>
-        retrieveFile: (file: FileType, apiKey: string) => Promise<File | undefined>
-        base64File: (file: FileType) => Promise<{ data: string; mimeType: string }>
-        listFiles: (apiKey: string) => Promise<File[]>
-        deleteFile: (fileId: string, apiKey: string) => Promise<void>
-      }
-      selectionMenu: {
-        action: (action: string) => Promise<void>
-      }
-      config: {
-        set: (key: string, value: any) => Promise<void>
-        get: (key: string) => Promise<any>
-      }
-      miniWindow: {
-        show: () => Promise<void>
-        hide: () => Promise<void>
-        close: () => Promise<void>
-        toggle: () => Promise<void>
-        setPin: (isPinned: boolean) => Promise<void>
-      }
-      aes: {
-        encrypt: (text: string, secretKey: string, iv: string) => Promise<{ iv: string; encryptedData: string }>
-        decrypt: (encryptedData: string, iv: string, secretKey: string) => Promise<string>
-      }
-      shell: {
-        openExternal: (url: string, options?: OpenExternalOptions) => Promise<void>
-      }
-      mcp: {
-        removeServer: (server: MCPServer) => Promise<void>
-        restartServer: (server: MCPServer) => Promise<void>
-        stopServer: (server: MCPServer) => Promise<void>
-        listTools: (server: MCPServer) => Promise<MCPTool[]>
-        callTool: ({
-          server,
-          name,
-          args
-        }: {
-          server: MCPServer
-          name: string
-          args: any
-        }) => Promise<MCPCallToolResponse>
-        listPrompts: (server: MCPServer) => Promise<MCPPrompt[]>
-        getPrompt: ({
-          server,
-          name,
-          args
-        }: {
-          server: MCPServer
-          name: string
-          args?: Record<string, any>
-        }) => Promise<GetMCPPromptResponse>
-        listResources: (server: MCPServer) => Promise<MCPResource[]>
-        getResource: ({ server, uri }: { server: MCPServer; uri: string }) => Promise<GetResourceResponse>
-        getInstallInfo: () => Promise<{ dir: string; uvPath: string; bunPath: string }>
-      }
-      copilot: {
-        getAuthMessage: (
-          headers?: Record<string, string>
-        ) => Promise<{ device_code: string; user_code: string; verification_uri: string }>
-        getCopilotToken: (device_code: string, headers?: Record<string, string>) => Promise<{ access_token: string }>
-        saveCopilotToken: (access_token: string) => Promise<void>
-        getToken: (headers?: Record<string, string>) => Promise<{ token: string }>
-        logout: () => Promise<void>
-        getUser: (token: string) => Promise<{ login: string; avatar: string }>
-      }
-      isBinaryExist: (name: string) => Promise<boolean>
-      getBinaryPath: (name: string) => Promise<string>
-      installUVBinary: () => Promise<void>
-      installBunBinary: () => Promise<void>
-      protocol: {
-        onReceiveData: (callback: (data: { url: string; params: any }) => void) => () => void
-      }
-      nutstore: {
-        getSSOUrl: () => Promise<string>
-        decryptToken: (token: string) => Promise<{ username: string; access_token: string }>
-        getDirectoryContents: (token: string, path: string) => Promise<any>
-      }
-      searchService: {
-        openSearchWindow: (uid: string) => Promise<string>
-        closeSearchWindow: (uid: string) => Promise<string>
-        openUrlInSearchWindow: (uid: string, url: string) => Promise<string>
-      }
-      webview: {
-        setOpenLinkExternal: (webviewId: number, isExternal: boolean) => Promise<void>
-      }
-    }
-  }
-}

src/preload/index.ts

@@ -9,7 +9,7 @@ import { CreateDirectoryOptions } from 'webdav'
 const api = {
   getAppInfo: () => ipcRenderer.invoke(IpcChannel.App_Info),
   reload: () => ipcRenderer.invoke(IpcChannel.App_Reload),
-  setProxy: (proxy: string) => ipcRenderer.invoke(IpcChannel.App_Proxy, proxy),
+  setProxy: (proxy: string | undefined) => ipcRenderer.invoke(IpcChannel.App_Proxy, proxy),
   checkForUpdate: () => ipcRenderer.invoke(IpcChannel.App_CheckForUpdate),
   showUpdateDialog: () => ipcRenderer.invoke(IpcChannel.App_ShowUpdateDialog),
   setLanguage: (lang: string) => ipcRenderer.invoke(IpcChannel.App_SetLanguage, lang),
@@ -50,16 +50,16 @@ const api = {
   },
   file: {
     select: (options?: OpenDialogOptions) => ipcRenderer.invoke(IpcChannel.File_Select, options),
-    upload: (filePath: string) => ipcRenderer.invoke(IpcChannel.File_Upload, filePath),
+    upload: (file: FileType) => ipcRenderer.invoke(IpcChannel.File_Upload, file),
     delete: (fileId: string) => ipcRenderer.invoke(IpcChannel.File_Delete, fileId),
     read: (fileId: string) => ipcRenderer.invoke(IpcChannel.File_Read, fileId),
     clear: () => ipcRenderer.invoke(IpcChannel.File_Clear),
     get: (filePath: string) => ipcRenderer.invoke(IpcChannel.File_Get, filePath),
     create: (fileName: string) => ipcRenderer.invoke(IpcChannel.File_Create, fileName),
     write: (filePath: string, data: Uint8Array | string) => ipcRenderer.invoke(IpcChannel.File_Write, filePath, data),
-    open: (options?: { decompress: boolean }) => ipcRenderer.invoke(IpcChannel.File_Open, options),
+    open: (options?: OpenDialogOptions) => ipcRenderer.invoke(IpcChannel.File_Open, options),
     openPath: (path: string) => ipcRenderer.invoke(IpcChannel.File_OpenPath, path),
-    save: (path: string, content: string, options?: { compress: boolean }) =>
+    save: (path: string, content: string | NodeJS.ArrayBufferView, options?: any) =>
       ipcRenderer.invoke(IpcChannel.File_Save, path, content, options),
     selectFolder: () => ipcRenderer.invoke(IpcChannel.File_SelectFolder),
     saveImage: (name: string, data: string) => ipcRenderer.invoke(IpcChannel.File_SaveImage, name, data),
@@ -108,7 +108,7 @@ const api = {
     base64File: (file: FileType) => ipcRenderer.invoke(IpcChannel.Gemini_Base64File, file),
     retrieveFile: (file: FileType, apiKey: string) => ipcRenderer.invoke(IpcChannel.Gemini_RetrieveFile, file, apiKey),
     listFiles: (apiKey: string) => ipcRenderer.invoke(IpcChannel.Gemini_ListFiles, apiKey),
-    deleteFile: (apiKey: string, fileId: string) => ipcRenderer.invoke(IpcChannel.Gemini_DeleteFile, apiKey, fileId)
+    deleteFile: (fileId: string, apiKey: string) => ipcRenderer.invoke(IpcChannel.Gemini_DeleteFile, fileId, apiKey)
   },
   selectionMenu: {
     action: (action: string) => ipcRenderer.invoke(IpcChannel.SelectionMenu_Action, action)
@@ -135,7 +135,7 @@ const api = {
     restartServer: (server: MCPServer) => ipcRenderer.invoke(IpcChannel.Mcp_RestartServer, server),
     stopServer: (server: MCPServer) => ipcRenderer.invoke(IpcChannel.Mcp_StopServer, server),
     listTools: (server: MCPServer) => ipcRenderer.invoke(IpcChannel.Mcp_ListTools, server),
-    callTool: ({ server, name, args }: { server: MCPServer; name: string; args?: Record<string, any> }) =>
+    callTool: ({ server, name, args }: { server: MCPServer; name: string; args: any }) =>
       ipcRenderer.invoke(IpcChannel.Mcp_CallTool, { server, name, args }),
     listPrompts: (server: MCPServer) => ipcRenderer.invoke(IpcChannel.Mcp_ListPrompts, server),
     getPrompt: ({ server, name, args }: { server: MCPServer; name: string; args?: Record<string, any> }) =>
@@ -146,7 +146,7 @@ const api = {
     getInstallInfo: () => ipcRenderer.invoke(IpcChannel.Mcp_GetInstallInfo)
   },
   shell: {
-    openExternal: shell.openExternal
+    openExternal: (url: string, options?: Electron.OpenExternalOptions) => shell.openExternal(url, options)
   },
   copilot: {
     getAuthMessage: (headers?: Record<string, string>) =>
@@ -213,3 +213,5 @@ if (process.contextIsolated) {
   // @ts-ignore (define in dts)
   window.api = api
 }
+
+export type WindowApiType = typeof api

src/preload/preload.d.ts

@@ -0,0 +1,11 @@
+import { ElectronAPI } from '@electron-toolkit/preload'
+
+import type { WindowApiType } from './index'
+
+/** you don't need to declare this in your code, it's automatically generated */
+declare global {
+  interface Window {
+    electron: ElectronAPI
+    api: WindowApiType
+  }
+}

src/renderer/src/store/shortcuts.ts

@@ -88,7 +88,8 @@ const getSerializableShortcuts = (shortcuts: Shortcut[]) => {
     key: shortcut.key,
     shortcut: [...shortcut.shortcut],
     enabled: shortcut.enabled,
-    system: shortcut.system
+    system: shortcut.system,
+    editable: shortcut.editable
   }))
 }
 

tsconfig.web.json

@@ -12,7 +12,8 @@
     "baseUrl": ".",
     "paths": {
       "@renderer/*": ["src/renderer/src/*"],
-      "@shared/*": ["packages/shared/*"]
+      "@shared/*": ["packages/shared/*"],
+      "@types": ["src/renderer/src/types/index.ts"]
     }
   }
 }