@bouko/electron 1.1.7 → 1.1.9

package/dist/communication/index.d.ts

@@ -1,7 +1,2 @@
-export declare class IpcManager {
-    id: string;
-    constructor(id: string);
-    on<T, K>(channel: string, cb: (params?: T) => Promise<K>): void;
-}
 export declare function setupAppIpc(): void;
 export * from "./manager";

package/dist/communication/index.js

@@ -1,14 +1,5 @@
 import { ipcMain, BrowserWindow, shell } from "electron";
 import { choosePath } from "../files/dialog";
-export class IpcManager {
-    id;
-    constructor(id) {
-        this.id = id;
-    }
-    on(channel, cb) {
-        ipcMain.handle(`${this.id}:${channel}`, (_, params) => cb(params));
-    }
-}
 export function setupAppIpc() {
     ipcMain.on("app:minimize", (event) => {
         const window = BrowserWindow.fromWebContents(event.sender);

package/dist/communication/manager.d.ts

@@ -1,6 +1,6 @@
 export type IpcSchema = Record<string, Record<string, {
-    input?: string | object;
-    result: any;
+    input?: unknown;
+    result: unknown;
 }>>;
 type Input<S extends IpcSchema, N extends keyof S, K extends keyof S[N]> = S[N][K] extends {
     input: infer I;
@@ -8,37 +8,16 @@ type Input<S extends IpcSchema, N extends keyof S, K extends keyof S[N]> = S[N][
 type Result<S extends IpcSchema, N extends keyof S, K extends keyof S[N]> = S[N][K] extends {
     result: infer R;
 } ? R : never;
-export type MainAdapter = {
-    handle: (channel: string, handler: (input: any) => any) => void;
-};
-export type RendererAdapter = {
-    invoke: (channel: string, input?: any) => Promise<any>;
-};
-type NamespaceMain<S extends IpcSchema, N extends keyof S> = {
+type Namespace<S extends IpcSchema, N extends keyof S> = {
     on<K extends keyof S[N] & string>(key: K, handler: (input: Input<S, N, K>) => Result<S, N, K> | Promise<Result<S, N, K>>): void;
 };
-type NamespaceRenderer<S extends IpcSchema, N extends keyof S> = {
-    call<K extends keyof S[N] & string>(key: K, input: Input<S, N, K>): Promise<Result<S, N, K>>;
-    call0<K extends keyof S[N] & string>(key: K): Input<S, N, K> extends undefined ? Promise<Result<S, N, K>> : never;
-};
-type MainClient<S extends IpcSchema> = {
-    [N in keyof S]: NamespaceMain<S, N>;
-};
-type RendererClient<S extends IpcSchema> = {
-    [N in keyof S]: NamespaceRenderer<S, N>;
+type Client<S extends IpcSchema> = {
+    [N in keyof S]: Namespace<S, N>;
 };
-export declare class IpcMainManager<S extends IpcSchema> {
-    private adapter;
-    private delimiter;
-    readonly ipc: MainClient<S>;
-    constructor(adapter: MainAdapter, delimiter?: string);
-    private makeNamespace;
-}
-export declare class IpcRendererManager<S extends IpcSchema> {
-    private adapter;
+export declare class IpcManager<S extends IpcSchema> {
     private delimiter;
-    readonly ipc: RendererClient<S>;
-    constructor(adapter: RendererAdapter, delimiter?: string);
+    readonly ipc: Client<S>;
+    constructor(delimiter?: string);
     private makeNamespace;
 }
 export {};

package/dist/communication/manager.js

@@ -1,34 +1,19 @@
-export class IpcMainManager {
-    adapter;
+import { ipcMain } from "electron";
+export class IpcManager {
     delimiter;
     ipc;
-    constructor(adapter, delimiter = ":") {
-        this.adapter = adapter;
+    constructor(delimiter = ":") {
         this.delimiter = delimiter;
-        this.ipc = new Proxy({}, { get: (_t, ns) => this.makeNamespace(ns) });
+        this.ipc = new Proxy({}, {
+            get: (_target, ns) => this.makeNamespace(ns),
+        });
     }
     makeNamespace(ns) {
         const ch = (key) => `${ns}${this.delimiter}${key}`;
         return {
             on: (key, handler) => {
-                this.adapter.handle(ch(key), (...args) => handler(...args));
-            }
-        };
-    }
-}
-export class IpcRendererManager {
-    adapter;
-    delimiter;
-    ipc;
-    constructor(adapter, delimiter = ":") {
-        this.adapter = adapter;
-        this.delimiter = delimiter;
-        this.ipc = new Proxy({}, { get: (_t, ns) => this.makeNamespace(ns) });
-    }
-    makeNamespace(ns) {
-        const ch = (key) => `${ns}${this.delimiter}${key}`;
-        return {
-            call: (key, ...args) => this.adapter.invoke(ch(key), ...args),
+                ipcMain.handle(ch(key), (_event, input) => handler(input));
+            },
         };
     }
 }

package/dist/csp/index.js

@@ -19,7 +19,7 @@ export const csp = "default-src 'self'; " +
     "style-src 'self'; " +
     "img-src 'self' data: https:; " +
     "font-src 'self' data:; " +
-    `connect-src 'self' blob: ${getEnv("DB_URL")}; ` +
+    `connect-src 'self' blob: ${getEnv("BASE_URL")} ${getEnv("DB_URL")}; ` +
     "media-src 'self' blob: data:; " +
     "worker-src 'self' blob:; " +
     "object-src 'none'; " +
@@ -31,7 +31,7 @@ export const devCsp = "default-src 'self' http://localhost:* blob: data:; " +
     "img-src 'self' data: blob: http://localhost:* https:; " +
     "media-src 'self' blob: data:; " +
     "worker-src 'self' blob: http://localhost:*; " +
-    `connect-src 'self' blob: http://localhost:* ws://localhost:* ${getEnv("DB_URL")};`;
+    `connect-src 'self' blob: http://localhost:* ws://localhost:* ${getEnv("BASE_URL")} ${getEnv("DB_URL")};`;
 export const setupCspPolicy = () => session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
     if (details.url.startsWith("file://") || details.url.startsWith("http://localhost")) {
         callback({

package/package.json

@@ -1,7 +1,7 @@
 {
 
   "name": "@bouko/electron",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "",
   "keywords": [],
   "author": "",