File size: 3,131 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 |
import { IPC } from './index'
import type { Ipc as GenericIpc } from './index'
type IpcIncomingMessage =
| {
type: 'evaluate'
args: string[]
}
| {
type: 'result'
id: number
error: string | null
data: any | null
}
type IpcOutgoingMessage =
| {
type: 'end'
data: string | undefined
duration: number
}
| {
type: 'info'
data: any
}
| {
type: 'request'
id: number
data: any
}
export type Ipc<IM, RM> = {
sendInfo(message: IM): Promise<void>
sendRequest(message: RM): Promise<unknown>
sendError(error: Error): Promise<never>
}
const ipc = IPC as GenericIpc<IpcIncomingMessage, IpcOutgoingMessage>
const queue: string[][] = []
export const run = async (
moduleFactory: () => Promise<{
init?: () => Promise<void>
default: (ipc: Ipc<any, any>, ...deserializedArgs: any[]) => any
}>
) => {
let nextId = 1
const requests = new Map()
const internalIpc = {
sendInfo: (message: any) =>
ipc.send({
type: 'info',
data: message,
}),
sendRequest: (message: any) => {
const id = nextId++
let resolve, reject
const promise = new Promise((res, rej) => {
resolve = res
reject = rej
})
requests.set(id, { resolve, reject })
return ipc
.send({ type: 'request', id, data: message })
.then(() => promise)
},
sendError: (error: Error) => {
return ipc.sendError(error)
},
}
// Initialize module and send ready message
let getValue: (ipc: Ipc<any, any>, ...deserializedArgs: any[]) => any
try {
const module = await moduleFactory()
if (typeof module.init === 'function') {
await module.init()
}
getValue = module.default
await ipc.sendReady()
} catch (err) {
await ipc.sendReady()
await ipc.sendError(err as Error)
}
// Queue handling
let isRunning = false
const run = async () => {
while (queue.length > 0) {
const args = queue.shift()!
try {
const value = await getValue(internalIpc, ...args)
await ipc.send({
type: 'end',
data:
value === undefined ? undefined : JSON.stringify(value, null, 2),
duration: 0,
})
} catch (e) {
await ipc.sendError(e as Error)
}
}
isRunning = false
}
// Communication handling
while (true) {
const msg = await ipc.recv()
switch (msg.type) {
case 'evaluate': {
queue.push(msg.args)
if (!isRunning) {
isRunning = true
run()
}
break
}
case 'result': {
const request = requests.get(msg.id)
if (request) {
requests.delete(msg.id)
if (msg.error) {
request.reject(new Error(msg.error))
} else {
request.resolve(msg.data)
}
}
break
}
default: {
console.error('unexpected message type', (msg as any).type)
process.exit(1)
}
}
}
}
export type { IpcIncomingMessage, IpcOutgoingMessage }
|