@noxfly/noxus 1.1.10 → 2.0.0

package/src/renderer-events.ts

@@ -0,0 +1,110 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
+/**
+ * Lightweight event registry to help renderer processes subscribe to
+ * push messages sent by the main process through Noxus.
+ */
+import { IRendererEventMessage, isRendererEventMessage } from 'src/request';
+
+export type RendererEventHandler<TPayload = unknown> = (payload: TPayload) => void;
+
+export interface RendererEventSubscription {
+    unsubscribe(): void;
+}
+
+export class RendererEventRegistry {
+    private readonly listeners = new Map<string, Set<RendererEventHandler>>();
+
+    /**
+     *
+     */
+    public subscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): RendererEventSubscription {
+        const normalizedEventName = eventName.trim();
+
+        if(normalizedEventName.length === 0) {
+            throw new Error('Renderer event name must be a non-empty string.');
+        }
+
+        const handlers = this.listeners.get(normalizedEventName) ?? new Set<RendererEventHandler>();
+
+        handlers.add(handler as RendererEventHandler);
+        this.listeners.set(normalizedEventName, handlers);
+
+        return {
+            unsubscribe: () => this.unsubscribe(normalizedEventName, handler as RendererEventHandler),
+        };
+    }
+
+    /**
+     *
+     */
+    public unsubscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): void {
+        const handlers = this.listeners.get(eventName);
+
+        if(!handlers) {
+            return;
+        }
+
+        handlers.delete(handler as RendererEventHandler);
+
+        if(handlers.size === 0) {
+            this.listeners.delete(eventName);
+        }
+    }
+
+    /**
+     *
+     */
+    public clear(eventName?: string): void {
+        if(eventName) {
+            this.listeners.delete(eventName);
+            return;
+        }
+
+        this.listeners.clear();
+    }
+
+    /**
+     *
+     */
+    public dispatch<TPayload>(message: IRendererEventMessage<TPayload>): void {
+        const handlers = this.listeners.get(message.event);
+
+        if(!handlers || handlers.size === 0) {
+            return;
+        }
+
+        handlers.forEach((handler) => {
+            try {
+                handler(message.payload as TPayload);
+            }
+            catch(error) {
+                console.error(`[Noxus] Renderer event handler for "${message.event}" threw an error.`, error);
+            }
+        });
+    }
+
+    /**
+     *
+     */
+    public tryDispatchFromMessageEvent(event: MessageEvent): boolean {
+        if(!isRendererEventMessage(event.data)) {
+            return false;
+        }
+
+        this.dispatch(event.data);
+        return true;
+    }
+
+    /**
+     *
+     */
+    public hasHandlers(eventName: string): boolean {
+        const handlers = this.listeners.get(eventName);
+        return !!handlers && handlers.size > 0;
+    }
+}

package/src/request.ts

@@ -20,6 +20,7 @@ export class Request {
 
     constructor(
         public readonly event: Electron.MessageEvent,
+        public readonly senderId: number,
         public readonly id: string,
         public readonly method: HttpMethod,
         public readonly path: string,
@@ -68,3 +69,29 @@ export interface IResponse<TBody = unknown> {
 export interface IBatchResponsePayload {
     responses: IResponse[];
 }
+
+export const RENDERER_EVENT_TYPE = 'noxus:event';
+
+export interface IRendererEventMessage<TPayload = unknown> {
+    type: typeof RENDERER_EVENT_TYPE;
+    event: string;
+    payload?: TPayload;
+}
+
+export function createRendererEventMessage<TPayload = unknown>(event: string, payload?: TPayload): IRendererEventMessage<TPayload> {
+    return {
+        type: RENDERER_EVENT_TYPE,
+        event,
+        payload,
+    };
+}
+
+export function isRendererEventMessage(value: unknown): value is IRendererEventMessage {
+    if(value === null || typeof value !== 'object') {
+        return false;
+    }
+
+    const possibleMessage = value as Partial<IRendererEventMessage>;
+
+    return possibleMessage.type === RENDERER_EVENT_TYPE && typeof possibleMessage.event === 'string';
+}

package/src/router.ts

@@ -213,7 +213,7 @@ export class Router {
 
             for(const [index, item] of payload.requests.entries()) {
                 const subRequestId = item.requestId ?? `${request.id}:${index}`;
-                const atomicRequest = new Request(request.event, subRequestId, item.method, item.path, item.body);
+                const atomicRequest = new Request(request.event, request.senderId, subRequestId, item.method, item.path, item.body);
                 batchResponses.push(await this.handleAtomic(atomicRequest));
             }
 

package/src/socket.ts

@@ -0,0 +1,73 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
+/**
+ * Centralizes MessagePort storage for renderer communication and handles
+ * push-event delivery back to renderer processes.
+ */
+import { Injectable } from 'src/decorators/injectable.decorator';
+import { createRendererEventMessage } from 'src/request';
+import { Logger } from 'src/utils/logger';
+
+interface RendererChannels {
+    request: Electron.MessageChannelMain;
+    socket: Electron.MessageChannelMain;
+}
+
+@Injectable('singleton')
+export class NoxSocket {
+    private readonly channels = new Map<number, RendererChannels>();
+
+    public register(senderId: number, requestChannel: Electron.MessageChannelMain, socketChannel: Electron.MessageChannelMain): void {
+        this.channels.set(senderId, { request: requestChannel, socket: socketChannel });
+    }
+
+    public get(senderId: number): RendererChannels | undefined {
+        return this.channels.get(senderId);
+    }
+
+    public unregister(senderId: number): void {
+        this.channels.delete(senderId);
+    }
+
+    public getSenderIds(): number[] {
+        return [...this.channels.keys()];
+    }
+
+    public emit<TPayload = unknown>(eventName: string, payload?: TPayload, targetSenderIds?: number[]): number {
+        const normalizedEvent = eventName.trim();
+
+        if(normalizedEvent.length === 0) {
+            throw new Error('Renderer event name must be a non-empty string.');
+        }
+
+        const recipients = targetSenderIds ?? this.getSenderIds();
+        let delivered = 0;
+
+        for(const senderId of recipients) {
+            const channel = this.channels.get(senderId);
+
+            if(!channel) {
+                Logger.warn(`No message channel found for sender ID: ${senderId} while emitting "${normalizedEvent}".`);
+                continue;
+            }
+
+            try {
+                channel.socket.port1.postMessage(createRendererEventMessage(normalizedEvent, payload));
+                delivered++;
+            }
+            catch(error) {
+                Logger.error(`[Noxus] Failed to emit "${normalizedEvent}" to sender ${senderId}.`, error);
+            }
+        }
+
+        return delivered;
+    }
+
+    public emitToRenderer<TPayload = unknown>(senderId: number, eventName: string, payload?: TPayload): boolean {
+        return this.emit(eventName, payload, [senderId]) > 0;
+    }
+}

package/tsup.config.ts

@@ -10,7 +10,8 @@ const copyrights = `
 
 export default defineConfig({
     entry: {
-        noxus: "src/index.ts"
+        renderer: "src/index.ts",
+        main: "src/main.ts",
     },
     keepNames: true,
     minifyIdentifiers: false,