@noxfly/noxus 1.1.10 → 1.2.0

package/dist/renderer.mjs

@@ -0,0 +1,236 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/request.ts
+import "reflect-metadata";
+
+// src/DI/app-injector.ts
+import "reflect-metadata";
+
+// src/exceptions.ts
+var _ResponseException = class _ResponseException extends Error {
+  constructor(statusOrMessage, message) {
+    let statusCode;
+    if (typeof statusOrMessage === "number") {
+      statusCode = statusOrMessage;
+    } else if (typeof statusOrMessage === "string") {
+      message = statusOrMessage;
+    }
+    super(message ?? "");
+    __publicField(this, "status", 0);
+    if (statusCode !== void 0) {
+      this.status = statusCode;
+    }
+    this.name = this.constructor.name.replace(/([A-Z])/g, " $1");
+  }
+};
+__name(_ResponseException, "ResponseException");
+var ResponseException = _ResponseException;
+var _InternalServerException = class _InternalServerException extends ResponseException {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 500);
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+
+// src/DI/app-injector.ts
+var _AppInjector = class _AppInjector {
+  constructor(name = null) {
+    __publicField(this, "name");
+    __publicField(this, "bindings", /* @__PURE__ */ new Map());
+    __publicField(this, "singletons", /* @__PURE__ */ new Map());
+    __publicField(this, "scoped", /* @__PURE__ */ new Map());
+    this.name = name;
+  }
+  /**
+   * Typically used to create a dependency injection scope
+   * at the "scope" level (i.e., per-request lifetime).
+   *
+   * SHOULD NOT BE USED by anything else than the framework itself.
+   */
+  createScope() {
+    const scope = new _AppInjector();
+    scope.bindings = this.bindings;
+    scope.singletons = this.singletons;
+    return scope;
+  }
+  /**
+   * Called when resolving a dependency,
+   * i.e., retrieving the instance of a given class.
+   */
+  resolve(target) {
+    const binding = this.bindings.get(target);
+    if (!binding) throw new InternalServerException(`Failed to resolve a dependency injection : No binding for type ${target.name}.
+Did you forget to use @Injectable() decorator ?`);
+    switch (binding.lifetime) {
+      case "transient":
+        return this.instantiate(binding.implementation);
+      case "scope": {
+        if (this.scoped.has(target)) {
+          return this.scoped.get(target);
+        }
+        const instance = this.instantiate(binding.implementation);
+        this.scoped.set(target, instance);
+        return instance;
+      }
+      case "singleton": {
+        if (binding.instance === void 0 && this.name === "root") {
+          binding.instance = this.instantiate(binding.implementation);
+          this.singletons.set(target, binding.instance);
+        }
+        return binding.instance;
+      }
+    }
+  }
+  /**
+   *
+   */
+  instantiate(target) {
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+    const params = paramTypes.map((p) => this.resolve(p));
+    return new target(...params);
+  }
+};
+__name(_AppInjector, "AppInjector");
+var AppInjector = _AppInjector;
+var RootInjector = new AppInjector("root");
+
+// src/request.ts
+var _Request = class _Request {
+  constructor(event, id, method, path, body) {
+    __publicField(this, "event");
+    __publicField(this, "id");
+    __publicField(this, "method");
+    __publicField(this, "path");
+    __publicField(this, "body");
+    __publicField(this, "context", RootInjector.createScope());
+    __publicField(this, "params", {});
+    this.event = event;
+    this.id = id;
+    this.method = method;
+    this.path = path;
+    this.body = body;
+    this.path = path.replace(/^\/|\/$/g, "");
+  }
+};
+__name(_Request, "Request");
+var Request = _Request;
+var RENDERER_EVENT_TYPE = "noxus:event";
+function createRendererEventMessage(event, payload) {
+  return {
+    type: RENDERER_EVENT_TYPE,
+    event,
+    payload
+  };
+}
+__name(createRendererEventMessage, "createRendererEventMessage");
+function isRendererEventMessage(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const possibleMessage = value;
+  return possibleMessage.type === RENDERER_EVENT_TYPE && typeof possibleMessage.event === "string";
+}
+__name(isRendererEventMessage, "isRendererEventMessage");
+
+// src/renderer-events.ts
+var _RendererEventRegistry = class _RendererEventRegistry {
+  constructor() {
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  /**
+   *
+   */
+  subscribe(eventName, handler) {
+    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) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.listeners.set(normalizedEventName, handlers);
+    return {
+      unsubscribe: /* @__PURE__ */ __name(() => this.unsubscribe(normalizedEventName, handler), "unsubscribe")
+    };
+  }
+  /**
+   *
+   */
+  unsubscribe(eventName, handler) {
+    const handlers = this.listeners.get(eventName);
+    if (!handlers) {
+      return;
+    }
+    handlers.delete(handler);
+    if (handlers.size === 0) {
+      this.listeners.delete(eventName);
+    }
+  }
+  /**
+   *
+   */
+  clear(eventName) {
+    if (eventName) {
+      this.listeners.delete(eventName);
+      return;
+    }
+    this.listeners.clear();
+  }
+  /**
+   *
+   */
+  dispatch(message) {
+    const handlers = this.listeners.get(message.event);
+    if (!handlers || handlers.size === 0) {
+      return;
+    }
+    handlers.forEach((handler) => {
+      try {
+        handler(message.payload);
+      } catch (error) {
+        console.error(`[Noxus] Renderer event handler for "${message.event}" threw an error.`, error);
+      }
+    });
+  }
+  /**
+   *
+   */
+  tryDispatchFromMessageEvent(event) {
+    if (!isRendererEventMessage(event.data)) {
+      return false;
+    }
+    this.dispatch(event.data);
+    return true;
+  }
+  /**
+   *
+   */
+  hasHandlers(eventName) {
+    const handlers = this.listeners.get(eventName);
+    return !!handlers && handlers.size > 0;
+  }
+};
+__name(_RendererEventRegistry, "RendererEventRegistry");
+var RendererEventRegistry = _RendererEventRegistry;
+export {
+  RENDERER_EVENT_TYPE,
+  RendererEventRegistry,
+  Request,
+  createRendererEventMessage,
+  isRendererEventMessage
+};
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+//# sourceMappingURL=renderer.mjs.map

package/package.json

@@ -1,50 +1,75 @@
 {
-  "name": "@noxfly/noxus",
-  "version": "1.1.10",
-  "main": "dist/noxus.js",
-  "types": "dist/noxus.d.ts",
-  "scripts": {
-    "build": "tsup",
-    "prepublishOnly": "npm run build",
-    "prepush": "npm run build",
-    "postbuild": "node scripts/postbuild.js"
-  },
-  "keywords": [
-    "noxus",
-    "nox",
-    "nodejs",
-    "typescript",
-    "framework",
-    "web framework",
-    "electron"
-  ],
-  "author": "NoxFly",
-  "license": "MIT",
-  "description": "Simulate lightweight HTTP-like requests between renderer and main process in Electron applications with MessagePort, with structured and modular design.",
-  "homepage": "https://github.com/NoxFly/noxus",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/NoxFly/noxus.git"
-  },
-  "engines": {
-    "node": ">= 20"
-  },
-  "devDependencies": {
-    "@stylistic/eslint-plugin": "^5.1.0",
-    "@swc/core": "^1.12.14",
-    "@typescript-eslint/eslint-plugin": "^8.36.0",
-    "@typescript-eslint/parser": "^8.36.0",
-    "electron": "^37.2.1",
-    "eslint": "^9.31.0",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^51.3.4",
-    "eslint-plugin-prefer-arrow": "^1.2.3",
-    "tsc-alias": "^1.8.16",
-    "tsup": "^8.5.0",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.36.0"
-  },
-  "peerDependencies": {
-    "reflect-metadata": "^0.2.2"
-  }
+    "name": "@noxfly/noxus",
+    "version": "1.2.0",
+    "main": "dist/main.js",
+    "module": "dist/main.mjs",
+    "types": "dist/main.d.ts",
+    "exports": {
+        ".": {
+            "browser": {
+                "types": "./dist/renderer.d.ts",
+                "import": "./dist/renderer.mjs",
+                "require": "./dist/renderer.js"
+            },
+            "default": {
+                "types": "./dist/main.d.ts",
+                "import": "./dist/main.mjs",
+                "require": "./dist/main.js"
+            }
+        },
+        "./renderer": {
+            "types": "./dist/renderer.d.ts",
+            "import": "./dist/renderer.mjs",
+            "require": "./dist/renderer.js"
+        },
+        "./main": {
+            "types": "./dist/main.d.ts",
+            "import": "./dist/main.mjs",
+            "require": "./dist/main.js"
+        }
+    },
+    "scripts": {
+        "build": "tsup",
+        "prepublishOnly": "npm run build",
+        "prepush": "npm run build",
+        "postbuild": "node scripts/postbuild.js"
+    },
+    "keywords": [
+        "noxus",
+        "nox",
+        "nodejs",
+        "typescript",
+        "framework",
+        "web framework",
+        "electron"
+    ],
+    "author": "NoxFly",
+    "license": "MIT",
+    "description": "Simulate lightweight HTTP-like requests between renderer and main process in Electron applications with MessagePort, with structured and modular design.",
+    "homepage": "https://github.com/NoxFly/noxus",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/NoxFly/noxus.git"
+    },
+    "engines": {
+        "node": ">= 20"
+    },
+    "devDependencies": {
+        "@stylistic/eslint-plugin": "^5.1.0",
+        "@swc/core": "^1.12.14",
+        "@typescript-eslint/eslint-plugin": "^8.36.0",
+        "@typescript-eslint/parser": "^8.36.0",
+        "electron": "^37.2.1",
+        "eslint": "^9.31.0",
+        "eslint-plugin-import": "^2.32.0",
+        "eslint-plugin-jsdoc": "^51.3.4",
+        "eslint-plugin-prefer-arrow": "^1.2.3",
+        "tsc-alias": "^1.8.16",
+        "tsup": "^8.5.0",
+        "typescript": "^5.8.3",
+        "typescript-eslint": "^8.36.0"
+    },
+    "peerDependencies": {
+        "reflect-metadata": "^0.2.2"
+    }
 }

package/scripts/postbuild.js

@@ -1,10 +1,11 @@
 const fs = require('fs');
 const path = require('path');
 
-const frameworkName = 'noxus';
+function uniqueDocBlocks(filepath) {
+    if(!fs.existsSync(filepath)) {
+        return;
+    }
 
-function removeDuplicateCopyrights(filename) {
-    const filepath = path.join(__dirname, '../dist/' + filename);
     const content = fs.readFileSync(filepath, 'utf8');
 
     const reg = /\/\*\*[\t ]*\n(?: \*.*\n)*? \* *@copyright.*\n(?: \*.*\n)*? \*\/\n?/gm;
@@ -21,6 +22,10 @@ function removeDuplicateCopyrights(filename) {
     fs.writeFileSync(filepath, deduped);
 }
 
+const distDir = path.join(__dirname, '../dist');
 
-removeDuplicateCopyrights(`${frameworkName}.d.mts`);
-removeDuplicateCopyrights(`${frameworkName}.d.ts`);
+for(const filename of fs.readdirSync(distDir)) {
+    if(filename.endsWith('.d.ts') || filename.endsWith('.d.mts')) {
+        uniqueDocBlocks(path.join(distDir, filename));
+    }
+}

package/src/app.ts

@@ -9,6 +9,7 @@ import { Injectable } from "src/decorators/injectable.decorator";
 import { IMiddleware } from "src/decorators/middleware.decorator";
 import { inject } from "src/DI/app-injector";
 import { IRequest, IResponse, Request } from "src/request";
+import { NoxSocket } from "src/socket";
 import { Router } from "src/router";
 import { Logger } from "src/utils/logger";
 import { Type } from "src/utils/types";
@@ -30,11 +31,37 @@ export interface IApp {
  */
 @Injectable('singleton')
 export class NoxApp {
-    private readonly messagePorts = new Map<number, Electron.MessageChannelMain>();
     private app: IApp | undefined;
+    private readonly onRendererMessage = async (event: Electron.MessageEvent): Promise<void> => {
+        const { senderId, requestId, path, method, body }: IRequest = event.data;
+
+        const channel = this.socket.get(senderId);
+
+        if(!channel) {
+            Logger.error(`No message channel found for sender ID: ${senderId}`);
+            return;
+        }
+
+        try {
+            const request = new Request(event, requestId, method, path, body);
+            const response = await this.router.handle(request);
+            channel.port1.postMessage(response);
+        }
+        catch(err: any) {
+            const response: IResponse = {
+                requestId,
+                status: 500,
+                body: null,
+                error: err.message || 'Internal Server Error',
+            };
+
+            channel.port1.postMessage(response);
+        }
+    };
 
     constructor(
         private readonly router: Router,
+        private readonly socket: NoxSocket,
     ) {}
 
     /**
@@ -62,47 +89,18 @@ export class NoxApp {
     private giveTheRendererAPort(event: Electron.IpcMainInvokeEvent): void {
         const senderId = event.sender.id;
 
-        if(this.messagePorts.has(senderId)) {
+        if(this.socket.get(senderId)) {
             this.shutdownChannel(senderId);
         }
 
         const channel = new MessageChannelMain();
-        this.messagePorts.set(senderId, channel);
 
-        channel.port1.on('message', this.onRendererMessage.bind(this));
+        channel.port1.on('message', this.onRendererMessage);
         channel.port1.start();
 
-        event.sender.postMessage('port', { senderId }, [channel.port2]);
-    }
-
-    /**
-     * Electron specific message handling.
-     * Replaces HTTP calls by using Electron's IPC mechanism.
-     */
-    private async onRendererMessage(event: Electron.MessageEvent): Promise<void> {
-        const { senderId, requestId, path, method, body }: IRequest = event.data;
-
-        const channel = this.messagePorts.get(senderId);
-
-        if(!channel) {
-            Logger.error(`No message channel found for sender ID: ${senderId}`);
-            return;
-        }
-        try {
-            const request = new Request(event, requestId, method, path, body);
-            const response = await this.router.handle(request);
-            channel.port1.postMessage(response);
-        }
-        catch(err: any) {
-            const response: IResponse = {
-                requestId,
-                status: 500,
-                body: null,
-                error: err.message || 'Internal Server Error',
-            };
+        this.socket.register(senderId, channel);
 
-            channel.port1.postMessage(response);
-        }
+        event.sender.postMessage('port', { senderId }, [channel.port2]);
     }
 
     /**
@@ -122,18 +120,18 @@ export class NoxApp {
      * @param remove - Whether to remove the channel from the messagePorts map.
      */
     private shutdownChannel(channelSenderId: number): void {
-        const channel = this.messagePorts.get(channelSenderId);
+        const channel = this.socket.get(channelSenderId);
 
         if(!channel) {
             Logger.warn(`No message channel found for sender ID: ${channelSenderId}`);
             return;
         }
 
-        channel.port1.off('message', this.onRendererMessage.bind(this));
+        channel.port1.off('message', this.onRendererMessage);
         channel.port1.close();
         channel.port2.close();
 
-        this.messagePorts.delete(channelSenderId);
+        this.socket.unregister(channelSenderId);
     }
 
     /**
@@ -141,11 +139,9 @@ export class NoxApp {
      * This method is called when all windows are closed, and it cleans up the message channels
      */
     private async onAllWindowsClosed(): Promise<void> {
-        this.messagePorts.forEach((channel, senderId) => {
+        for(const senderId of this.socket.getSenderIds()) {
             this.shutdownChannel(senderId);
-        });
-
-        this.messagePorts.clear();
+        }
 
         Logger.info('All windows closed, shutting down application...');
         await this.app?.dispose();

package/src/index.ts

@@ -4,17 +4,5 @@
  * @author NoxFly
  */
 
-export * from './DI/app-injector';
-export * from './router';
-export * from './app';
-export * from './bootstrap';
-export * from './exceptions';
-export * from './decorators/middleware.decorator';
-export * from './decorators/guards.decorator';
-export * from './decorators/controller.decorator';
-export * from './decorators/injectable.decorator';
-export * from './decorators/method.decorator';
-export * from './decorators/module.decorator';
-export * from './utils/logger';
-export * from './utils/types';
 export * from './request';
+export * from './renderer-events';

package/src/main.ts

@@ -0,0 +1,25 @@
+/**
+ * @copyright 2025 NoxFly
+ * @license MIT
+ * @author NoxFly
+ */
+
+/**
+ * Entry point for Electron main-process consumers.
+ */
+export * from './DI/app-injector';
+export * from './router';
+export * from './app';
+export * from './bootstrap';
+export * from './exceptions';
+export * from './decorators/middleware.decorator';
+export * from './decorators/guards.decorator';
+export * from './decorators/controller.decorator';
+export * from './decorators/injectable.decorator';
+export * from './decorators/method.decorator';
+export * from './decorators/module.decorator';
+export * from './utils/logger';
+export * from './utils/types';
+export * from './request';
+export * from './renderer-events';
+export * from './socket';

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;
+    }
+}