The electron-ipc-tunnel from cu3po42

electron-ipc-tunnel's People

Stargazers

Watchers

electron-ipc-tunnel's Issues

Take it to the next level

Would be awesome to have a generic-like API to take it to the next level. See what I mean.

api.ts:

export interface IpcAPI
{
    methodA(path: string): Promise<boolean>;
    methodB(path: string): Promise<void>;
}

client.ts:

import IpcClient from "electron-ipc-tunnel/client";
import {IpcAPI} from "./api";

class IpcProxy implements ProxyHandler<any>
{
    private readonly client: IpcClient;

    constructor()
    {
        this.client = new IpcClient();
    }

    get (target: any, p: PropertyKey, receiver: any): any
    {
        const zis = this;
        const methodName = p.toString();

        return function()
        {
            const args = [methodName];
            for (const arg of arguments)
            {
                args.push(arg);
            }
            
            return zis.client.send.apply(zis.client, args);
        };
    }
}

export const ipc: IpcAPI = new Proxy<any>({}, new IpcProxy()) as IpcAPI;

server.ts:


import register from "electron-ipc-tunnel/server";
import { IpcAPI } from "./api"

export class IpcServer implements IpcAPI
{
    public async methodA(path: string): Promise<boolean>
    {
        // implementation
    }

    public async methodB(path: string): Promise<void> 
    {
        // implementation
    }
}

const server: IpcServer = new IpcServer();

for (const methodName of Object.getOwnPropertyNames(Object.getPrototypeOf(server)))
{
    if (methodName == "constructor")
        continue;

    register(methodName, (receive: any, ...args: any[]) =>
    {
        return (server as any)[methodName].apply(server, args);
    });
}

In that way you can have IPC communication that acts pretty much undistinguishable from regular method all.

render: