@delight-rpc/electron 6.0.1 → 6.0.3

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@delight-rpc/electron",
-  "version": "6.0.1",
+  "version": "6.0.3",
   "description": "",
   "keywords": [],
   "files": [
-    "lib"
+    "lib",
+    "src"
   ],
   "type": "module",
   "main": "lib/index.js",
@@ -42,7 +43,7 @@
     "@typescript-eslint/parser": "^5.55.0",
     "cross-env": "^7.0.3",
     "delight-rpc": "^6.0.0",
-    "electron": "^16.0.7",
+    "electron": "^28.0.0",
     "eslint": "8.36.0",
     "husky": "4",
     "jest": "^29.5.0",
@@ -64,6 +65,6 @@
   },
   "peerDependencies": {
     "delight-rpc": "^5.0.0 || ^6.0.0",
-    "electron": "^16.0.1"
+    "electron": ">=16.0.1 <29"
   }
 }

package/src/client.ts

@@ -0,0 +1,217 @@
+import * as DelightRPC from 'delight-rpc'
+import { Deferred } from 'extra-promise'
+import Electron from 'electron'
+import { CustomError } from '@blackglory/errors'
+import { IResponse, IError, IBatchResponse } from '@delight-rpc/protocol'
+
+export function createClientInMain<IAPI extends object>(
+  port: Electron.MessagePortMain
+, { parameterValidators, expectedVersion, channel }: {
+    parameterValidators?: DelightRPC.ParameterValidators<IAPI>
+  , expectedVersion?: string
+  , channel?: string
+  } = {}
+): [client: DelightRPC.ClientProxy<IAPI>, close: () => void] {
+  const pendings: Record<string, Deferred<IResponse<unknown>> | undefined> = {}
+
+  port.addListener('message', handler)
+
+  const client = DelightRPC.createClient<IAPI>(
+    async function send(request) {
+      const res = new Deferred<IResponse<unknown>>()
+      pendings[request.id] = res
+      try {
+        port.postMessage(request)
+        return await res
+      } finally {
+        delete pendings[request.id]
+      }
+    }
+  , {
+      parameterValidators
+    , expectedVersion
+    , channel
+    }
+  )
+
+  return [client, close]
+
+  function close(): void {
+    port.removeListener('message', handler)
+
+    for (const [key, deferred] of Object.entries(pendings)) {
+      deferred!.reject(new ClientClosed())
+      delete pendings[key]
+    }
+  }
+
+  function handler(event: Electron.MessageEvent): void {
+    const res = event.data
+    if (DelightRPC.isResult(res) || DelightRPC.isError(res)) {
+      pendings[res.id]?.resolve(res)
+    }
+  }
+}
+
+export function createClientInRenderer<IAPI extends object>(
+  port: MessagePort
+, { parameterValidators, expectedVersion, channel }: {
+    parameterValidators?: DelightRPC.ParameterValidators<IAPI>
+    expectedVersion?: string
+    channel?: string
+  } = {}
+): [client: DelightRPC.ClientProxy<IAPI>, close: () => void] {
+  const pendings: Record<
+    string
+  , | Deferred<IResponse<unknown>>
+    | undefined
+  > = {}
+
+  port.addEventListener('message', handler)
+
+  const client = DelightRPC.createClient<IAPI>(
+    async function send(request) {
+      const res = new Deferred<IResponse<unknown>>()
+      pendings[request.id] = res
+      try {
+        port.postMessage(request)
+        return await res
+      } finally {
+        delete pendings[request.id]
+      }
+    }
+  , {
+      parameterValidators
+    , expectedVersion
+    , channel
+    }
+  )
+
+  return [client, close]
+
+  function close(): void {
+    port.removeEventListener('message', handler)
+
+    for (const [key, deferred] of Object.entries(pendings)) {
+      deferred!.reject(new ClientClosed())
+      delete pendings[key]
+    }
+  }
+
+  function handler(event: MessageEvent): void {
+    const res = event.data
+    if (DelightRPC.isResult(res) || DelightRPC.isError(res)) {
+      pendings[res.id]?.resolve(res)
+    }
+  }
+}
+
+export function createBatchClientInMain<DataType>(
+  port: Electron.MessagePortMain
+, { expectedVersion, channel }: {
+    expectedVersion?: string
+    channel?: string
+  } = {}
+): [client: DelightRPC.BatchClient<DataType>, close: () => void] {
+  const pendings: Record<
+    string
+  , | Deferred<IError | IBatchResponse<unknown>>
+    | undefined
+  > = {}
+
+  port.addListener('message', handler)
+
+  const client = new DelightRPC.BatchClient(
+    async function send(request) {
+      const res = new Deferred<
+      | IError
+      | IBatchResponse<unknown>
+      >()
+      pendings[request.id] = res
+      try {
+        port.postMessage(request)
+        return await res
+      } finally {
+        delete pendings[request.id]
+      }
+    }
+  , {
+      expectedVersion
+    , channel
+    }
+  )
+
+  return [client, close]
+
+  function close(): void {
+    port.removeListener('message', handler)
+
+    for (const [key, deferred] of Object.entries(pendings)) {
+      deferred!.reject(new ClientClosed())
+      delete pendings[key]
+    }
+  }
+
+  function handler(event: Electron.MessageEvent): void {
+    const res = event.data
+    if (DelightRPC.isError(res) || DelightRPC.isBatchResponse(res)) {
+      pendings[res.id]?.resolve(res)
+    }
+  }
+}
+
+export function createBatchClientInRenderer<DataType>(
+  port: MessagePort
+, { expectedVersion, channel }: {
+    expectedVersion?: string
+    channel?: string
+  } = {}
+): [client: DelightRPC.BatchClient<DataType>, close: () => void] {
+  const pendings: Record<
+    string
+  , | Deferred<IError | IBatchResponse<unknown>>
+    | undefined
+  > = {}
+
+  port.addEventListener('message', handler)
+
+  const client = new DelightRPC.BatchClient(
+    async function send(request) {
+      const res = new Deferred<
+      | IError
+      | IBatchResponse<unknown>
+      >()
+      pendings[request.id] = res
+      try {
+        port.postMessage(request)
+        return await res
+      } finally {
+        delete pendings[request.id]
+      }
+    }
+  , {
+      expectedVersion
+    , channel
+    }
+  )
+
+  return [client, close]
+
+  function close(): void {
+    port.removeEventListener('message', handler)
+
+    for (const [key, deferred] of Object.entries(pendings)) {
+      deferred!.reject(new ClientClosed())
+      delete pendings[key]
+    }
+  }
+
+  function handler(event: MessageEvent): void {
+    const res = event.data
+    if (DelightRPC.isError(res) || DelightRPC.isBatchResponse(res)) {
+      pendings[res.id]?.resolve(res)
+    }
+  }
+}
+
+export class ClientClosed extends CustomError {}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './client.js'
+export * from './server.js'

package/src/server.ts

@@ -0,0 +1,71 @@
+import * as DelightRPC from 'delight-rpc'
+import Electron from 'electron'
+import { isntNull } from '@blackglory/prelude'
+
+export function createServerInMain<IAPI extends object>(
+  api: DelightRPC.ImplementationOf<IAPI>
+, port: Electron.MessagePortMain
+, { parameterValidators, version, channel, ownPropsOnly }: {
+    parameterValidators?: DelightRPC.ParameterValidators<IAPI>
+    version?: `${number}.${number}.${number}`
+    channel?: string | RegExp | typeof DelightRPC.AnyChannel
+    ownPropsOnly?: boolean
+  } = {}
+): () => void {
+  port.addListener('message', handler)
+  return () => port.removeListener('message', handler)
+
+  async function handler(event: Electron.MessageEvent): Promise<void> {
+    const req = event.data
+    if (DelightRPC.isRequest(req) || DelightRPC.isBatchRequest(req)) {
+      const result = await DelightRPC.createResponse(
+        api
+      , req
+      , {
+          parameterValidators
+        , version
+        , channel
+        , ownPropsOnly
+        }
+      )
+
+      if (isntNull(result)) {
+        port.postMessage(result)
+      }
+    }
+  }
+}
+
+export function createServerInRenderer<IAPI extends object>(
+  api: DelightRPC.ImplementationOf<IAPI>
+, port: MessagePort
+, { parameterValidators, version, channel, ownPropsOnly }: {
+    parameterValidators?: DelightRPC.ParameterValidators<IAPI>
+    version?: `${number}.${number}.${number}`
+    channel?: string | RegExp | typeof DelightRPC.AnyChannel
+    ownPropsOnly?: boolean
+  } = {}
+): () => void {
+  port.addEventListener('message', handler)
+  return () => port.removeEventListener('message', handler)
+
+  async function handler(event: MessageEvent): Promise<void> {
+    const req = event.data
+    if (DelightRPC.isRequest(req) || DelightRPC.isBatchRequest(req)) {
+      const result = await DelightRPC.createResponse(
+        api
+      , req
+      , {
+          parameterValidators
+        , version
+        , channel
+        , ownPropsOnly
+        }
+      )
+
+      if (isntNull(result)) {
+        port.postMessage(result)
+      }
+    }
+  }
+}