@noxfly/noxus 1.1.10 → 1.2.0

package/src/request.ts

@@ -68,3 +68,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/socket.ts

@@ -0,0 +1,68 @@
+/**
+ * @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';
+
+@Injectable('singleton')
+export class NoxSocket {
+    private readonly messagePorts = new Map<number, Electron.MessageChannelMain>();
+
+    public register(senderId: number, channel: Electron.MessageChannelMain): void {
+        this.messagePorts.set(senderId, channel);
+    }
+
+    public get(senderId: number): Electron.MessageChannelMain | undefined {
+        return this.messagePorts.get(senderId);
+    }
+
+    public unregister(senderId: number): void {
+        this.messagePorts.delete(senderId);
+    }
+
+    public getSenderIds(): number[] {
+        return [...this.messagePorts.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.messagePorts.get(senderId);
+
+            if(!channel) {
+                Logger.warn(`No message channel found for sender ID: ${senderId} while emitting "${normalizedEvent}".`);
+                continue;
+            }
+
+            try {
+                channel.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,