@yagisumi/e7ipc-electron v0.1.0

@yagisumi/e7ipc-electron

Electron IPC wrapper similar to Electron v7.

Installation

$ npm i @yagisumi/e7ipc-electron

Requirements

@yagisumi/e7ipc-electron7 ― electron v7 or later @yagisumi/e7ipc-electron ― electron v5 or later

Usage

// messages.ts
export const CHANNEL = 'app'

type MapType<T, U = keyof T> = U extends keyof T ? T[U] : never

export interface Requests {
  hello: {
    type: 'hello'
  }
  bye: {
    type: 'bye'
  }
}

export type Request = MapType<Requests>

export interface Responses {
  ok: {
    type: 'ok'
  }
  error: {
    type: 'error'
    message: string
  }
}

export type Response = MapType<Responses>

export const unexpected = (): Response => {
  return { type: 'error', message: 'unexpected' }
}

// handler.ts
import { Handler } from '@yagisumi/e7ipc-electron'
import { Request, Response } from './messages'

export const handler: Handler<Request, Response> = async (_, req) => {
  if (req.type === 'hello') {
    return { type: 'ok' }
  } else if (req.type === 'bye') {
    return { type: 'error', message: `Don't say goodbye.` }
  } else {
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    const unreachable: never = req
    throw 'unreachable'
  }
}

// process: Main
import { ipcMain } from 'electron'
import { Request, Response, CHANNEL } from './messages'
import { handler } from './handler'
import { createServer } from '@yagisumi/e7ipc-electron'

const server = createServer<Request, Response>(CHANNEL, ipcMain)
server.handle(handler)

// Process: Renderer
import { ipcRenderer } from 'electron'
import { Request, Response, CHANNEL, unexpected } from './messages'
import { createClient } from '@yagisumi/e7ipc-electron'

const client = createClient<Request, Response>(CHANNEL, ipcRenderer)

async function foo() {
  const r1 = await client.invoke({ type: 'hello' }).catch(unexpected)
  // r1: { type: 'ok' }
  const r2 = await client.invoke({ type: 'bye' }).catch(unexpected)
  // r2: { type: 'error', message: `Don't say goodbye.` }
}

Test

You can test handler with @yagisumi/e7ipc-mock

import { Mock } from '@yagisumi/e7ipc-mock'
import { Request, Response } from '@/messages'
import { handler } from '@/handler'

describe('handler', () => {
  test('request', async () => {
    const mock = new Mock<Request, Response>()
    mock.handle(handler)

    const r1 = await mock.invoke({ type: 'hello' })
    expect(r1.type).toBe('ok')

    const r2 = await mock.invoke({ type: 'bye' })
    expect(r2.type).toBe('error')
  })
})

License

MIT License