feat: typed-ipc

Author: alex8088

.github/workflows/release-tag.yml

@@ -5,6 +5,7 @@ on:
       - 'tsconfig*'
       - 'preload*'
       - 'eslint-config*'
+      - 'typed-ipc*'
 
 name: Create Release
 

package.json

@@ -11,6 +11,7 @@
     "lint": "eslint --ext .ts packages/*/src/**",
     "typecheck": "tsc --noEmit",
     "build:preload": "pnpm run -C packages/preload build",
+    "build:ipc": "pnpm run -C packages/typed-ipc build",
     "build:utils": "pnpm run -C packages/utils build",
     "dev": "pnpm run -C packages/playground start"
   },
@@ -28,6 +29,9 @@
     ]
   },
   "devDependencies": {
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^11.1.6",
     "@types/node": "^18.19.29",
     "@typescript-eslint/eslint-plugin": "^7.5.0",
     "@typescript-eslint/parser": "^7.5.0",
@@ -39,6 +43,9 @@
     "picocolors": "^1.0.0",
     "prettier": "^3.2.5",
     "rimraf": "^5.0.5",
+    "rollup": "^4.21.0",
+    "rollup-plugin-dts": "^6.1.1",
+    "rollup-plugin-rm": "^1.0.2",
     "simple-git-hooks": "^2.11.1",
     "tslib": "^2.6.2",
     "typescript": "^5.4.3",

packages/typed-ipc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present, Alex.Wei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/typed-ipc/README.md

@@ -0,0 +1,105 @@
+# @electron-toolkit/typed-ipc
+
+Type-safe Electron IPC, best practices in TypeScript.
+
+Type checking and intellisense are available both in the main process and the renderer process. Both the listener parameters, handler parameters and return value types can be inspected and sensed, and you will not miss any modifications.
+
+It provide a good development experience. Constrain the IPC registration of the main process and the calling of the renderer process, and avoid low-level errors. At the same time, it maintains the original writing method of IPC, which is more conducive to reading and understanding rather than over-encapsulating Electorn's IPC.
+
+## Usage
+
+### Install
+
+```sh
+npm i @electron-toolkit/preload @electron-toolkit/typed-ipc
+```
+
+### Get Started
+
+1. Use [@electron-toolkit/preload](https://github.com/alex8088/electron-toolkit/tree/master/packages/preload) to expose Electron APIs.
+
+   You can expose it in the specified preload script:
+
+   ```ts
+   import { contextBridge } from 'electron'
+   import { electronAPI } from '@electron-toolkit/preload'
+
+   if (process.contextIsolated) {
+     try {
+       contextBridge.exposeInMainWorld('electron', electronAPI)
+     } catch (error) {
+       console.error(error)
+     }
+   } else {
+     window.electron = electronAPI
+   }
+   ```
+
+   or
+
+   ```ts
+   import { exposeElectronAPI } from '@electron-toolkit/preload'
+
+   exposeElectronAPI()
+   ```
+
+2. Add `*.d.ts` declaration file to define IPC event type constraints. And remember to include it in your tsconfig to make sure it takes effect.
+
+   ```ts
+   // Main process ipc events
+   type IpcEvents =
+     | {
+         ping: [string] // listener event map
+       }
+     | {
+         'say-hello': () => string // handler event map
+       }
+
+   //Renderer ipc events
+   type IpcRendererEvent = {
+     ready: [boolean]
+   }
+   ```
+
+3. Register a listener or handler in the main process, or send a message to the renderer.
+
+   ```ts
+   import { IpcListener， IpcEmitter } from '@electron-toolkit/typed-ipc/main'
+
+   const ipc = new IpcListener<IpcEvents>()
+
+   const emitter = new IpcEmitter<IpcRendererEvent>()
+
+   ipc.on('ping', (e, arg) => {
+     console.log(arg)
+     emitter.send(e.sender, 'ready', true)
+   })
+
+   ipc.handle('say-hello', () => {
+     return 'hello'
+   })
+   ```
+
+4. Send a message from the render process to the main process, or listen for messages from the main process.
+
+   ```ts
+   import { IpcListener， IpcEmitter } from '@electron-toolkit/typed-ipc/renderer'
+
+   const ipc = new IpcListener<IpcRendererEvent>()
+
+   const emitter = new IpcEmitter<IpcEvents>()
+
+   ipc.on('ready', (e, arg) => {
+     console.log(arg)
+   })
+
+   emitter.send('ping', 'pong')
+
+   emitter.invoke('say-hello').then((str) => {
+     console.log(str)
+   })
+   ```
+
+## License
+
+[MIT](./LICENSE) © alex.wei

packages/typed-ipc/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@electron-toolkit/typed-ipc",
+  "version": "0.0.0",
+  "description": "Type-safe Electron IPC, best practices in TypeScript.",
+  "main": "dist/main.cjs",
+  "module": "dist/main.mjs",
+  "types": "dist/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "import": "./dist/main.mjs",
+      "require": "./dist/main.cjs"
+    },
+    "./main": {
+      "types": "./dist/main.d.ts",
+      "import": "./dist/main.mjs",
+      "require": "./dist/main.cjs"
+    },
+    "./renderer": {
+      "types": "./dist/renderer.d.ts",
+      "import": "./dist/renderer.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "Alex Wei<https://github.com/alex8088>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alex8088/electron-toolkit.git",
+    "directory": "packages/typed-ipc"
+  },
+  "bugs": {
+    "url": "https://github.com/alex8088/electron-toolkit/issues"
+  },
+  "homepage": "https://github.com/alex8088/electron-toolkit/tree/master/packages/typed-ipc#readme",
+  "keywords": [
+    "electron",
+    "toolkit",
+    "ipc"
+  ],
+  "scripts": {
+    "build": "rollup -c rollup.config.ts --configPlugin typescript"
+  },
+  "peerDependencies": {
+    "electron": ">=13.0.0",
+    "@electron-toolkit/preload": ">=3.0.0"
+  }
+}

packages/typed-ipc/rollup.config.ts

@@ -0,0 +1,67 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import { defineConfig } from 'rollup'
+import resolve from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'
+import ts from '@rollup/plugin-typescript'
+import dts from 'rollup-plugin-dts'
+import rm from 'rollup-plugin-rm'
+
+export default defineConfig([
+  {
+    input: ['src/main.ts'],
+    output: [
+      {
+        entryFileNames: '[name].cjs',
+        chunkFileNames: 'chunks/lib-[hash].cjs',
+        format: 'cjs',
+        dir: 'dist'
+      },
+      {
+        entryFileNames: '[name].mjs',
+        chunkFileNames: 'chunks/lib-[hash].mjs',
+        format: 'es',
+        dir: 'dist'
+      }
+    ],
+    external: ['electron'],
+    plugins: [
+      resolve(),
+      commonjs(),
+      ts({
+        compilerOptions: {
+          rootDir: 'src',
+          declaration: true,
+          outDir: 'dist/types'
+        }
+      }),
+      rm('dist', 'buildStart')
+    ]
+  },
+  {
+    input: ['src/renderer.ts'],
+    output: [
+      { file: './dist/renderer.mjs', format: 'es' },
+      { name: 'renderer', file: './dist/renderer.js', format: 'iife' }
+    ],
+    plugins: [
+      ts({
+        compilerOptions: {
+          rootDir: 'src',
+          declaration: true,
+          outDir: 'dist/types'
+        }
+      })
+    ]
+  },
+  {
+    input: ['dist/types/main.d.ts'],
+    output: [{ file: './dist/main.d.ts', format: 'es' }],
+    plugins: [dts()],
+    external: ['electron']
+  },
+  {
+    input: ['dist/types/renderer.d.ts'],
+    output: [{ file: './dist/renderer.d.ts', format: 'es' }],
+    plugins: [dts(), rm('dist/types', 'buildEnd')]
+  }
+])

packages/typed-ipc/src/global.d.ts

@@ -0,0 +1,7 @@
+import { ElectronAPI } from '@electron-toolkit/preload'
+
+declare global {
+  interface Window {
+    electron: ElectronAPI
+  }
+}

packages/typed-ipc/src/main.ts

@@ -0,0 +1,60 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ipcMain } from 'electron'
+import type { IpcEventMap, IpcListenEventMap, ExtractArgs, ExtractHandler } from './types'
+
+export * from './types'
+
+/**
+ * Typed listener for Electron `ipcMain`.
+ */
+export class IpcListener<T extends IpcEventMap> {
+  private listeners: string[] = []
+  private handlers: string[] = []
+
+  /**
+   * Listen to `channel`.
+   */
+  on<E extends keyof ExtractArgs<T>>(
+    channel: Extract<E, string>,
+    listener: (e: Electron.IpcMainEvent, ...args: ExtractArgs<T>[E]) => void | Promise<void>
+  ): void {
+    this.listeners.push(channel)
+    ipcMain.on(channel, listener as (e: Electron.IpcMainEvent, ...args: any[]) => void)
+  }
+
+  /**
+   * Handle a renderer invoke request.
+   */
+  handle<E extends keyof ExtractHandler<T>>(
+    channel: Extract<E, string>,
+    listener: (
+      e: Electron.IpcMainInvokeEvent,
+      ...args: Parameters<ExtractHandler<T>[E]>
+    ) => ReturnType<ExtractHandler<T>[E]> | Promise<ReturnType<ExtractHandler<T>[E]>>
+  ): void {
+    this.handlers.push(channel)
+    ipcMain.handle(channel, listener as (event: Electron.IpcMainInvokeEvent, ...args: any[]) => any)
+  }
+
+  /**
+   * Dispose all listeners and handlers.
+   */
+  dispose(): void {
+    this.listeners.forEach(c => ipcMain.removeAllListeners(c))
+    this.listeners = []
+    this.handlers.forEach(c => ipcMain.removeHandler(c))
+    this.handlers = []
+  }
+}
+
+/**
+ * Typed emitter for sending an asynchronous message to the renderer process.
+ */
+export class IpcEmitter<T extends IpcListenEventMap> {
+  /**
+   * Send an asynchronous message to the renderer process.
+   */
+  send<E extends keyof T>(sender: Electron.WebContents, channel: Extract<E, string>, ...args: T[E]): void {
+    sender.send(channel, ...args)
+  }
+}

packages/typed-ipc/src/renderer.ts

@@ -0,0 +1,42 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { IpcEventMap, IpcListenEventMap, ExtractArgs, ExtractHandler } from './types'
+
+export * from './types'
+
+/**
+ * Typed emitter for Electron `ipcRenderer`.
+ */
+export class IpcEmitter<T extends IpcEventMap> {
+  send<E extends keyof ExtractArgs<T>>(channel: Extract<E, string>, ...args: ExtractArgs<T>[E]): void {
+    window.electron.ipcRenderer.send(channel, ...args)
+  }
+
+  invoke<E extends keyof ExtractHandler<T>>(
+    channel: Extract<E, string>,
+    ...args: Parameters<ExtractHandler<T>[E]>
+  ): Promise<ReturnType<ExtractHandler<T>[E]>> {
+    return window.electron.ipcRenderer.invoke(channel, ...args)
+  }
+}
+
+/**
+ * Typed listener for Electron `ipcRenderer`.
+ */
+export class IpcListener<T extends IpcListenEventMap> {
+  on<E extends keyof T>(
+    channel: Extract<E, string>,
+    listener: (e: Electron.IpcRendererEvent, ...args: T[E]) => void
+  ): void | Promise<void> {
+    window.electron.ipcRenderer.on(channel, listener as (event: Electron.IpcRendererEvent, ...args: any[]) => void)
+  }
+
+  once<E extends keyof T>(
+    channel: Extract<E, string>,
+    listener: (e: Electron.IpcRendererEvent, ...args: T[E]) => void | Promise<void>
+  ): () => void {
+    return window.electron.ipcRenderer.once(
+      channel,
+      listener as (event: Electron.IpcRendererEvent, ...args: any[]) => void
+    )
+  }
+}