@delight-rpc/electron 6.0.3 → 6.0.5

package/README.md

@@ -7,14 +7,20 @@ yarn add @delight-rpc/electron
 ```
 
 ## Usage
+If your application sends RPC requests immediately after creating the RPC client,
+you need to create the RPC server as soon as possible,
+which means your corresponding code needs to be as **synchronized** as possible.
+
 ### Main as Client, Renderer as Server
+#### api.d.ts
 ```ts
-// api.d.ts
 interface IAPI {
   echo(message: string): string
 }
+```
 
-// main.js
+#### main.js
+```ts
 import { app, ipcMain } from 'electron'
 import { createClientInMain } from '@delight-rpc/electron'
 
@@ -32,8 +38,10 @@ const window = new BrowserWindow({
   webPreferences: { preload: 'preload.js' }
 })
 window.loadFile('renderer.html')
+```
 
-// preload.js
+#### preload.js
+```ts
 import { ipcRenderer } from 'electron'
 
 window.addEventListener('message', event => {
@@ -42,8 +50,10 @@ window.addEventListener('message', event => {
     ipcRenderer.postMessage('message-port', null, [port])
   }
 })
+```
 
-// renderer.js
+#### renderer.js
+```ts
 import { createServerInRenderer } from '@delight-rpc/electron'
 
 const api: IAPI = {
@@ -62,13 +72,15 @@ window.postMessage('message-port', '*', [channel.port2])
 ```
 
 ### Renderer as Client, Main as Server
+#### api.d.ts
 ```ts
-// api.d.ts
 interface IAPI {
   echo(message: string): string
 }
+```
 
-// main.js
+#### main.js
+```ts
 import { app, ipcMain } from 'electron'
 import { createClientInMain } from '@delight-rpc/electron'
 
@@ -80,7 +92,7 @@ const api: IAPI = {
 
 await app.whenReady()
 
-ipcMain.on('message-port', async event => {
+ipcMain.on('message-port', event => {
   const [port] = event.ports
 
   port.start()
@@ -91,8 +103,10 @@ const window = new BrowserWindow({
   webPreferences: { preload: 'preload.js' }
 })
 window.loadFile('renderer.html')
+```
 
-// preload.js
+#### preload.js
+```ts
 import { ipcRenderer } from 'electron'
 
 window.addEventListener('message', event => {
@@ -101,8 +115,10 @@ window.addEventListener('message', event => {
     ipcRenderer.postMessage('message-port', null, [port])
   }
 })
+```
 
-// renderer.js
+#### renderer.js
+```ts
 import { createClientInRenderer } from '@delight-rpc/electron'
 
 // create the MessageChannel in the renderer,
@@ -116,13 +132,15 @@ await client.echo('hello world')
 ```
 
 ### Renderer as Client, Renderer as Server
+#### api.d.ts
 ```ts
-// api.d.ts
 interface IAPI {
   echo(message: string): string
 }
+```
 
-// main.js
+#### main.js
+```ts
 import { app, ipcMain, MessageChannelMain } from 'electron'
 
 await app.whenReady()
@@ -140,8 +158,10 @@ windowB.loadFile('renderer-b.html')
 const channel = new MessageChannelMain()
 windowA.webContents.postMessage('message-port', null, [channel.port1])
 windowB.webContents.postMessage('message-port', null, [channel.port2])
+```
 
-// preload.ts
+#### preload.ts
+```ts
 import { ipcRenderer, contextBridge } from 'electron'
 import { Deferred } from 'extra-promise'
 
@@ -155,8 +175,10 @@ ipcRenderer.on('message-port', event => {
   await ready
   window.postMessage('message-port', '*', [port])
 })
+```
 
-// renderer-a.js
+#### renderer-a.js
+```ts
 import { createServerInRenderer } from '@delight-rpc/electron'
 
 const api: IAPI = {
@@ -175,8 +197,10 @@ window.addEventListener('message', async event => {
 })
 
 window.ready()
+```
 
-// renderer-b.js
+#### renderer-b.js
+```ts
 import { createClientInRenderer } from '@delight-rpc/electron'
 
 window.addEventListener('message', async event => {

package/lib/client.d.ts

@@ -1,23 +1,23 @@
-import * as DelightRPC from 'delight-rpc';
-import Electron from 'electron';
-import { CustomError } from '@blackglory/errors';
-export declare 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];
-export declare function createClientInRenderer<IAPI extends object>(port: MessagePort, { parameterValidators, expectedVersion, channel }?: {
-    parameterValidators?: DelightRPC.ParameterValidators<IAPI>;
-    expectedVersion?: string;
-    channel?: string;
-}): [client: DelightRPC.ClientProxy<IAPI>, close: () => void];
-export declare function createBatchClientInMain<DataType>(port: Electron.MessagePortMain, { expectedVersion, channel }?: {
-    expectedVersion?: string;
-    channel?: string;
-}): [client: DelightRPC.BatchClient<DataType>, close: () => void];
-export declare function createBatchClientInRenderer<DataType>(port: MessagePort, { expectedVersion, channel }?: {
-    expectedVersion?: string;
-    channel?: string;
-}): [client: DelightRPC.BatchClient<DataType>, close: () => void];
-export declare class ClientClosed extends CustomError {
-}
+import * as DelightRPC from 'delight-rpc';
+import Electron from 'electron';
+import { CustomError } from '@blackglory/errors';
+export declare 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];
+export declare function createClientInRenderer<IAPI extends object>(port: MessagePort, { parameterValidators, expectedVersion, channel }?: {
+    parameterValidators?: DelightRPC.ParameterValidators<IAPI>;
+    expectedVersion?: string;
+    channel?: string;
+}): [client: DelightRPC.ClientProxy<IAPI>, close: () => void];
+export declare function createBatchClientInMain<DataType>(port: Electron.MessagePortMain, { expectedVersion, channel }?: {
+    expectedVersion?: string;
+    channel?: string;
+}): [client: DelightRPC.BatchClient<DataType>, close: () => void];
+export declare function createBatchClientInRenderer<DataType>(port: MessagePort, { expectedVersion, channel }?: {
+    expectedVersion?: string;
+    channel?: string;
+}): [client: DelightRPC.BatchClient<DataType>, close: () => void];
+export declare class ClientClosed extends CustomError {
+}

package/lib/client.js

@@ -1,140 +1,140 @@
-import * as DelightRPC from 'delight-rpc';
-import { Deferred } from 'extra-promise';
-import { CustomError } from '@blackglory/errors';
-export function createClientInMain(port, { parameterValidators, expectedVersion, channel } = {}) {
-    const pendings = {};
-    port.addListener('message', handler);
-    const client = DelightRPC.createClient(async function send(request) {
-        const res = new Deferred();
-        pendings[request.id] = res;
-        try {
-            port.postMessage(request);
-            return await res;
-        }
-        finally {
-            delete pendings[request.id];
-        }
-    }, {
-        parameterValidators,
-        expectedVersion,
-        channel
-    });
-    return [client, close];
-    function close() {
-        port.removeListener('message', handler);
-        for (const [key, deferred] of Object.entries(pendings)) {
-            deferred.reject(new ClientClosed());
-            delete pendings[key];
-        }
-    }
-    function handler(event) {
-        var _a;
-        const res = event.data;
-        if (DelightRPC.isResult(res) || DelightRPC.isError(res)) {
-            (_a = pendings[res.id]) === null || _a === void 0 ? void 0 : _a.resolve(res);
-        }
-    }
-}
-export function createClientInRenderer(port, { parameterValidators, expectedVersion, channel } = {}) {
-    const pendings = {};
-    port.addEventListener('message', handler);
-    const client = DelightRPC.createClient(async function send(request) {
-        const res = new Deferred();
-        pendings[request.id] = res;
-        try {
-            port.postMessage(request);
-            return await res;
-        }
-        finally {
-            delete pendings[request.id];
-        }
-    }, {
-        parameterValidators,
-        expectedVersion,
-        channel
-    });
-    return [client, close];
-    function close() {
-        port.removeEventListener('message', handler);
-        for (const [key, deferred] of Object.entries(pendings)) {
-            deferred.reject(new ClientClosed());
-            delete pendings[key];
-        }
-    }
-    function handler(event) {
-        var _a;
-        const res = event.data;
-        if (DelightRPC.isResult(res) || DelightRPC.isError(res)) {
-            (_a = pendings[res.id]) === null || _a === void 0 ? void 0 : _a.resolve(res);
-        }
-    }
-}
-export function createBatchClientInMain(port, { expectedVersion, channel } = {}) {
-    const pendings = {};
-    port.addListener('message', handler);
-    const client = new DelightRPC.BatchClient(async function send(request) {
-        const res = new Deferred();
-        pendings[request.id] = res;
-        try {
-            port.postMessage(request);
-            return await res;
-        }
-        finally {
-            delete pendings[request.id];
-        }
-    }, {
-        expectedVersion,
-        channel
-    });
-    return [client, close];
-    function close() {
-        port.removeListener('message', handler);
-        for (const [key, deferred] of Object.entries(pendings)) {
-            deferred.reject(new ClientClosed());
-            delete pendings[key];
-        }
-    }
-    function handler(event) {
-        var _a;
-        const res = event.data;
-        if (DelightRPC.isError(res) || DelightRPC.isBatchResponse(res)) {
-            (_a = pendings[res.id]) === null || _a === void 0 ? void 0 : _a.resolve(res);
-        }
-    }
-}
-export function createBatchClientInRenderer(port, { expectedVersion, channel } = {}) {
-    const pendings = {};
-    port.addEventListener('message', handler);
-    const client = new DelightRPC.BatchClient(async function send(request) {
-        const res = new Deferred();
-        pendings[request.id] = res;
-        try {
-            port.postMessage(request);
-            return await res;
-        }
-        finally {
-            delete pendings[request.id];
-        }
-    }, {
-        expectedVersion,
-        channel
-    });
-    return [client, close];
-    function close() {
-        port.removeEventListener('message', handler);
-        for (const [key, deferred] of Object.entries(pendings)) {
-            deferred.reject(new ClientClosed());
-            delete pendings[key];
-        }
-    }
-    function handler(event) {
-        var _a;
-        const res = event.data;
-        if (DelightRPC.isError(res) || DelightRPC.isBatchResponse(res)) {
-            (_a = pendings[res.id]) === null || _a === void 0 ? void 0 : _a.resolve(res);
-        }
-    }
-}
-export class ClientClosed extends CustomError {
-}
+import * as DelightRPC from 'delight-rpc';
+import { Deferred } from 'extra-promise';
+import { CustomError } from '@blackglory/errors';
+export function createClientInMain(port, { parameterValidators, expectedVersion, channel } = {}) {
+    const pendings = {};
+    port.addListener('message', handler);
+    const client = DelightRPC.createClient(async function send(request) {
+        const res = new Deferred();
+        pendings[request.id] = res;
+        try {
+            port.postMessage(request);
+            return await res;
+        }
+        finally {
+            delete pendings[request.id];
+        }
+    }, {
+        parameterValidators,
+        expectedVersion,
+        channel
+    });
+    return [client, close];
+    function close() {
+        port.removeListener('message', handler);
+        for (const [key, deferred] of Object.entries(pendings)) {
+            deferred.reject(new ClientClosed());
+            delete pendings[key];
+        }
+    }
+    function handler(event) {
+        var _a;
+        const res = event.data;
+        if (DelightRPC.isResult(res) || DelightRPC.isError(res)) {
+            (_a = pendings[res.id]) === null || _a === void 0 ? void 0 : _a.resolve(res);
+        }
+    }
+}
+export function createClientInRenderer(port, { parameterValidators, expectedVersion, channel } = {}) {
+    const pendings = {};
+    port.addEventListener('message', handler);
+    const client = DelightRPC.createClient(async function send(request) {
+        const res = new Deferred();
+        pendings[request.id] = res;
+        try {
+            port.postMessage(request);
+            return await res;
+        }
+        finally {
+            delete pendings[request.id];
+        }
+    }, {
+        parameterValidators,
+        expectedVersion,
+        channel
+    });
+    return [client, close];
+    function close() {
+        port.removeEventListener('message', handler);
+        for (const [key, deferred] of Object.entries(pendings)) {
+            deferred.reject(new ClientClosed());
+            delete pendings[key];
+        }
+    }
+    function handler(event) {
+        var _a;
+        const res = event.data;
+        if (DelightRPC.isResult(res) || DelightRPC.isError(res)) {
+            (_a = pendings[res.id]) === null || _a === void 0 ? void 0 : _a.resolve(res);
+        }
+    }
+}
+export function createBatchClientInMain(port, { expectedVersion, channel } = {}) {
+    const pendings = {};
+    port.addListener('message', handler);
+    const client = new DelightRPC.BatchClient(async function send(request) {
+        const res = new Deferred();
+        pendings[request.id] = res;
+        try {
+            port.postMessage(request);
+            return await res;
+        }
+        finally {
+            delete pendings[request.id];
+        }
+    }, {
+        expectedVersion,
+        channel
+    });
+    return [client, close];
+    function close() {
+        port.removeListener('message', handler);
+        for (const [key, deferred] of Object.entries(pendings)) {
+            deferred.reject(new ClientClosed());
+            delete pendings[key];
+        }
+    }
+    function handler(event) {
+        var _a;
+        const res = event.data;
+        if (DelightRPC.isError(res) || DelightRPC.isBatchResponse(res)) {
+            (_a = pendings[res.id]) === null || _a === void 0 ? void 0 : _a.resolve(res);
+        }
+    }
+}
+export function createBatchClientInRenderer(port, { expectedVersion, channel } = {}) {
+    const pendings = {};
+    port.addEventListener('message', handler);
+    const client = new DelightRPC.BatchClient(async function send(request) {
+        const res = new Deferred();
+        pendings[request.id] = res;
+        try {
+            port.postMessage(request);
+            return await res;
+        }
+        finally {
+            delete pendings[request.id];
+        }
+    }, {
+        expectedVersion,
+        channel
+    });
+    return [client, close];
+    function close() {
+        port.removeEventListener('message', handler);
+        for (const [key, deferred] of Object.entries(pendings)) {
+            deferred.reject(new ClientClosed());
+            delete pendings[key];
+        }
+    }
+    function handler(event) {
+        var _a;
+        const res = event.data;
+        if (DelightRPC.isError(res) || DelightRPC.isBatchResponse(res)) {
+            (_a = pendings[res.id]) === null || _a === void 0 ? void 0 : _a.resolve(res);
+        }
+    }
+}
+export class ClientClosed extends CustomError {
+}
 //# sourceMappingURL=client.js.map

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,3 +1,3 @@
-export * from './client.js';
-export * from './server.js';
+export * from './client.js';
+export * from './server.js';
 //# sourceMappingURL=index.js.map

package/lib/server.d.ts

@@ -1,14 +1,14 @@
-import * as DelightRPC from 'delight-rpc';
-import Electron from 'electron';
-export declare 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;
-export declare 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;
+import * as DelightRPC from 'delight-rpc';
+import Electron from 'electron';
+export declare 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;
+export declare 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;

package/lib/server.js

@@ -1,39 +1,39 @@
-import * as DelightRPC from 'delight-rpc';
-import { isntNull } from '@blackglory/prelude';
-export function createServerInMain(api, port, { parameterValidators, version, channel, ownPropsOnly } = {}) {
-    port.addListener('message', handler);
-    return () => port.removeListener('message', handler);
-    async function handler(event) {
-        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(api, port, { parameterValidators, version, channel, ownPropsOnly } = {}) {
-    port.addEventListener('message', handler);
-    return () => port.removeEventListener('message', handler);
-    async function handler(event) {
-        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);
-            }
-        }
-    }
-}
+import * as DelightRPC from 'delight-rpc';
+import { isntNull } from '@blackglory/prelude';
+export function createServerInMain(api, port, { parameterValidators, version, channel, ownPropsOnly } = {}) {
+    port.addListener('message', handler);
+    return () => port.removeListener('message', handler);
+    async function handler(event) {
+        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(api, port, { parameterValidators, version, channel, ownPropsOnly } = {}) {
+    port.addEventListener('message', handler);
+    return () => port.removeEventListener('message', handler);
+    async function handler(event) {
+        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);
+            }
+        }
+    }
+}
 //# sourceMappingURL=server.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delight-rpc/electron",
-  "version": "6.0.3",
+  "version": "6.0.5",
   "description": "",
   "keywords": [],
   "files": [
@@ -43,7 +43,7 @@
     "@typescript-eslint/parser": "^5.55.0",
     "cross-env": "^7.0.3",
     "delight-rpc": "^6.0.0",
-    "electron": "^28.0.0",
+    "electron": "^34.1.1",
     "eslint": "8.36.0",
     "husky": "4",
     "jest": "^29.5.0",
@@ -65,6 +65,6 @@
   },
   "peerDependencies": {
     "delight-rpc": "^5.0.0 || ^6.0.0",
-    "electron": ">=16.0.1 <29"
+    "electron": ">=16.0.1 <35"
   }
 }