@cityofzion/bs-electron 0.0.1

package/dist/main.d.ts

@@ -0,0 +1,3 @@
+import { TApi, TExposedApi } from './utils';
+export declare function eraseApi(api: any, prefix?: string): TExposedApi;
+export declare function exposeApiToRenderer<T extends TApi>(api: T): void;

package/dist/main.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exposeApiToRenderer = exports.eraseApi = void 0;
+const utils_1 = require("./utils");
+const utils_2 = require("./utils");
+const electron_1 = require("electron");
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const exposedApis = new Map();
+let initialized = false;
+// Erase the api to expose all methods and properties to renderer. It also supports nested objects
+function eraseApi(api, prefix) {
+    const { asyncMethods, syncMethods, properties } = (0, utils_1.getPropertiesAndMethods)(api);
+    // As it is a recursive function, we need to add the prefix to the methods and properties
+    const response = {
+        asyncMethods: asyncMethods.map(method => (prefix ? `${prefix}.${method}` : method)),
+        syncMethods: syncMethods.map(method => (prefix ? `${prefix}.${method}` : method)),
+        properties: properties.map(property => (prefix ? `${prefix}.${property}` : property)),
+    };
+    // Iterate for all properties to discover nested objects
+    properties.forEach(property => {
+        const propertyValue = api[property];
+        // If the property is not an object, we don't need to iterate over it. Array is also considered an object so we need to disconsider it
+        if (typeof propertyValue !== 'object' ||
+            Array.isArray(propertyValue) ||
+            propertyValue instanceof Map ||
+            propertyValue instanceof Set)
+            return;
+        const propertyWithPrefix = prefix ? `${prefix}.${property}` : property;
+        // Recursive call to discover nested properties and methods
+        const nestedPropertiesAndMethods = eraseApi(propertyValue, propertyWithPrefix);
+        // Add the nested properties and methods to the response
+        response.syncMethods.push(...nestedPropertiesAndMethods.syncMethods);
+        response.asyncMethods.push(...nestedPropertiesAndMethods.asyncMethods);
+        response.properties.push(...nestedPropertiesAndMethods.properties);
+        // Remove the actual property because it is a instance and can't be serialized by ipc
+        response.properties.splice(response.properties.indexOf(propertyWithPrefix), 1);
+    });
+    return response;
+}
+exports.eraseApi = eraseApi;
+function exposeApiToRenderer(api) {
+    init();
+    // Class name
+    const apiName = api.constructor.name;
+    const apiIsAlreadyExposed = exposedApis.has(apiName);
+    if (apiIsAlreadyExposed) {
+        console.warn(`API ${apiName} is already exposed to renderer`);
+        return;
+    }
+    const apiClone = (0, lodash_clonedeep_1.default)(api);
+    const { asyncMethods, properties, syncMethods } = eraseApi(apiClone);
+    // For each property, we need to create a listener so renderer can request the property value
+    properties.forEach(property => {
+        electron_1.ipcMain.on((0, utils_2.buildIpcChannelName)(apiName, property), event => {
+            try {
+                const value = (0, utils_1.getValueFromPath)(api, property);
+                event.returnValue = { data: value };
+            }
+            catch (error) {
+                event.returnValue = { error: error.message };
+            }
+        });
+    });
+    // For each syncMethods, we need to create a listener so renderer can request the property value. We need to bind the function to the api instance to keep the context, the getValueFromPath function will do this for us
+    syncMethods.forEach(method => {
+        electron_1.ipcMain.on((0, utils_2.buildIpcChannelName)(apiName, method), (event, ...args) => {
+            try {
+                const func = (0, utils_1.getValueFromPath)(api, method);
+                const data = func(...args);
+                event.returnValue = { data };
+            }
+            catch (error) {
+                event.returnValue = { error: error.message };
+            }
+        });
+    });
+    // For each asyncMethods, we need to create a listener so renderer can request the property value.  We need to bind the function to the api instance to keep the context, the getValueFromPath function will do this for us
+    asyncMethods.forEach(method => {
+        electron_1.ipcMain.handle((0, utils_2.buildIpcChannelName)(apiName, method), (_event, ...args) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const func = (0, utils_1.getValueFromPath)(api, method);
+                const data = yield func(...args);
+                return { data };
+            }
+            catch (error) {
+                return { error: error.message };
+            }
+        }));
+    });
+    exposedApis.set(apiName, { properties, asyncMethods, syncMethods });
+}
+exports.exposeApiToRenderer = exposeApiToRenderer;
+// This function is called only once to initialize the ipcMain listener so renderer can request the exposed api
+function init() {
+    if (initialized)
+        return;
+    initialized = true;
+    electron_1.ipcMain.on(utils_1.GET_EXPOSED_API_CHANNEL, (event, apiName) => {
+        const exposedApi = exposedApis.get(apiName);
+        event.returnValue = exposedApi;
+    });
+}

package/dist/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@cityofzion/bs-electron",
+  "version": "0.0.1",
+  "repository": "https://github.com/CityOfZion/blockchain-services",
+  "author": "Coz",
+  "license": "MIT",
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint .",
+    "format": "eslint --fix"
+  },
+  "dependencies": {
+    "@cityofzion/blockchain-service": "workspace:*",
+    "lodash.clonedeep": "~4.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "~20.2.5",
+    "@typescript-eslint/eslint-plugin": "^6.5.0",
+    "@typescript-eslint/parser": "^6.5.0",
+    "eslint": "^8.48.0",
+    "ts-node": "10.9.1",
+    "typescript": "4.9.5",
+    "@types/lodash.clonedeep": "~4.5.9"
+  },
+  "peerDependencies": {
+    "electron": "*",
+    "@electron-toolkit/preload": "*"
+  }
+}

package/dist/preload.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/preload.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const preload_1 = require("@electron-toolkit/preload");
+if (process.contextIsolated) {
+    try {
+        electron_1.contextBridge.exposeInMainWorld('ipcBsElectron', preload_1.electronAPI.ipcRenderer);
+    }
+    catch (error) {
+        console.error(error);
+    }
+}
+else {
+    // @ts-ignore (define in dts)
+    window.ipcBsElectron = ipcRenderer;
+}

package/dist/renderer.d.ts

@@ -0,0 +1,2 @@
+import { TApi } from './utils';
+export declare function bindApiFromMain<T extends TApi = any>(apiName: string): T;

package/dist/renderer.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindApiFromMain = void 0;
+const utils_1 = require("./utils");
+const boundApis = new Map();
+function bindApiFromMain(apiName) {
+    const boundApi = boundApis.get(apiName);
+    if (boundApi) {
+        return boundApi;
+    }
+    // Request the exposed api from main
+    const exposedApi = window.ipcBsElectron.sendSync(utils_1.GET_EXPOSED_API_CHANNEL, apiName);
+    if (!exposedApi) {
+        throw new Error(`API ${apiName} is not exposed to renderer`);
+    }
+    const api = {};
+    // For each property, we need to populate the api with a getter so the renderer can request the property value from main
+    exposedApi.properties.forEach(property => {
+        (0, utils_1.populateObjectFromPath)(api, String(property), {
+            get: () => {
+                const result = window.ipcBsElectron.sendSync((0, utils_1.buildIpcChannelName)(apiName, property));
+                if (result.error) {
+                    throw new Error('Ipc only supports stringified data');
+                }
+                return result.data;
+            },
+        });
+    });
+    // For each syncMethods, we need to populate the api with a function that will send a sync message to main to request the method execution result
+    exposedApi.syncMethods.forEach(method => {
+        (0, utils_1.populateObjectFromPath)(api, String(method), {
+            value: (...args) => {
+                const result = window.ipcBsElectron.sendSync((0, utils_1.buildIpcChannelName)(apiName, method), ...args);
+                if (result.error) {
+                    throw new Error(result.error);
+                }
+                return result.data;
+            },
+        });
+    });
+    // For each asyncMethods, we need to populate the api with a function that will send a sync message to main to request the method execution result
+    exposedApi.asyncMethods.forEach(method => {
+        (0, utils_1.populateObjectFromPath)(api, String(method), {
+            value: (...args) => __awaiter(this, void 0, void 0, function* () {
+                const result = yield window.ipcBsElectron.invoke((0, utils_1.buildIpcChannelName)(apiName, method), ...args);
+                if (result.error) {
+                    throw new Error(result.error);
+                }
+                return result.data;
+            }),
+        });
+    });
+    boundApis.set(apiName, api);
+    return api;
+}
+exports.bindApiFromMain = bindApiFromMain;

package/dist/utils.d.ts

@@ -0,0 +1,18 @@
+export declare const CHANNEL_PREFIX = "bsElectron";
+export declare const GET_EXPOSED_API_CHANNEL: string;
+export type TApi = {
+    [K in keyof any]: any;
+};
+export type TExposedApi = {
+    properties: string[];
+    syncMethods: string[];
+    asyncMethods: string[];
+};
+export declare function getPropertiesAndMethods(object: any): {
+    properties: string[];
+    syncMethods: string[];
+    asyncMethods: string[];
+};
+export declare function getValueFromPath(obj: any, path: string): any;
+export declare function populateObjectFromPath(obj: any, path: string, value: PropertyDescriptor & ThisType<any>): any;
+export declare function buildIpcChannelName<T>(apiName: string, methodOrProperty: keyof T): string;

package/dist/utils.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIpcChannelName = exports.populateObjectFromPath = exports.getValueFromPath = exports.getPropertiesAndMethods = exports.GET_EXPOSED_API_CHANNEL = exports.CHANNEL_PREFIX = void 0;
+exports.CHANNEL_PREFIX = 'bsElectron';
+exports.GET_EXPOSED_API_CHANNEL = `${exports.CHANNEL_PREFIX}:getExposedApi`;
+// It returns all properties and methods from an object and its prototype chain, that is, extended classes are also considered
+function getPropertiesAndMethods(object) {
+    const syncMethods = new Set();
+    const asyncMethods = new Set();
+    const properties = new Set();
+    do {
+        for (const key of Reflect.ownKeys(object)) {
+            if (key === 'constructor')
+                continue;
+            const keyString = String(key);
+            if (typeof object[key] === 'function') {
+                try {
+                    const funcResponse = object[key].call(object, {});
+                    if (funcResponse instanceof Promise) {
+                        funcResponse.catch(() => { }).then(() => { });
+                        asyncMethods.add(keyString);
+                        continue;
+                    }
+                    syncMethods.add(keyString);
+                }
+                catch (_a) {
+                    syncMethods.add(keyString);
+                }
+                continue;
+            }
+            properties.add(keyString);
+        }
+    } while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
+    return {
+        properties: Array.from(properties),
+        syncMethods: Array.from(syncMethods),
+        asyncMethods: Array.from(asyncMethods),
+    };
+}
+exports.getPropertiesAndMethods = getPropertiesAndMethods;
+function getValueFromPath(obj, path) {
+    return path.split('.').reduce((acc, key) => {
+        // If the key is a function, we need to bind it to the object to keep the context
+        if (typeof acc[key] === 'function') {
+            return acc[key].bind(acc);
+        }
+        return acc[key];
+    }, obj);
+}
+exports.getValueFromPath = getValueFromPath;
+function populateObjectFromPath(obj, path, value) {
+    var _a;
+    const splittedPath = path.split('.');
+    let tempObj = obj;
+    for (let i = 0; i < splittedPath.length; i++) {
+        const property = splittedPath[i];
+        if (i === splittedPath.length - 1) {
+            Object.defineProperty(tempObj, property, value);
+        }
+        else {
+            tempObj[property] = (_a = tempObj[property]) !== null && _a !== void 0 ? _a : {};
+            tempObj = tempObj[property];
+        }
+    }
+    return obj;
+}
+exports.populateObjectFromPath = populateObjectFromPath;
+function buildIpcChannelName(apiName, methodOrProperty) {
+    return `${exports.CHANNEL_PREFIX}:${apiName}:${String(methodOrProperty)}`;
+}
+exports.buildIpcChannelName = buildIpcChannelName;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@cityofzion/bs-electron",
+  "version": "0.0.1",
+  "repository": "https://github.com/CityOfZion/blockchain-services",
+  "author": "Coz",
+  "license": "MIT",
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "build": "tsc && cp package.json dist/",
+    "lint": "eslint .",
+    "format": "eslint --fix"
+  },
+  "dependencies": {
+    "@cityofzion/blockchain-service": "workspace:*",
+    "lodash.clonedeep": "~4.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "~20.2.5",
+    "@typescript-eslint/eslint-plugin": "^6.5.0",
+    "@typescript-eslint/parser": "^6.5.0",
+    "eslint": "^8.48.0",
+    "ts-node": "10.9.1",
+    "typescript": "4.9.5",
+    "@types/lodash.clonedeep": "~4.5.9"
+  },
+  "peerDependencies": {
+    "electron": "*",
+    "@electron-toolkit/preload": "*"
+  }
+}