@_traeop_/electron-modular 1.0.7 → 1.0.8

package/dist/@core/bootstrap/initialize-ipc/window-event-listeners.d.ts

@@ -1,3 +1,3 @@
 import type { BrowserWindow } from "electron";
 import type { TWindowManagerWithHandlers } from "../../types/window-manager.js";
-export declare const attachWindowEventListeners: (browserWindow: BrowserWindow, windowInstance: TWindowManagerWithHandlers) => void;
+export declare const attachWindowEventListeners: (win: BrowserWindow, inst: TWindowManagerWithHandlers) => void;

package/dist/@core/bootstrap/initialize-ipc/window-event-listeners.js

@@ -1,90 +1,61 @@
 const windowListeners = new WeakMap();
-const EVENT_PREFIX = "on";
-const WINDOW_PREFIX = "onWindow";
-const WEB_CONTENTS_PREFIX = "onWebContents";
 const getPrototypeMethodNames = (instance) => {
     const names = new Set();
     let proto = Object.getPrototypeOf(instance);
     while (proto && proto !== Object.prototype) {
-        Object.getOwnPropertyNames(proto).forEach((name) => {
-            if (name !== "constructor") {
-                names.add(name);
-            }
-        });
+        Object.getOwnPropertyNames(proto).forEach((n) => n !== "constructor" && names.add(n));
         proto = Object.getPrototypeOf(proto);
     }
     return Array.from(names);
 };
-const toEventName = (handlerName) => {
-    const cleaned = handlerName
-        .replace(WINDOW_PREFIX, "")
-        .replace(WEB_CONTENTS_PREFIX, "")
-        .replace(EVENT_PREFIX, "");
-    return cleaned
+const toEventName = (h) => {
+    const c = h.replace(/^(onWindow|onWebContents|on)/, "");
+    return c
         .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
         .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2")
         .toLowerCase();
 };
-const isHandlerName = (name) => {
-    return name.startsWith(EVENT_PREFIX);
-};
-const isWebContentsHandler = (name) => {
-    return name.startsWith(WEB_CONTENTS_PREFIX);
-};
-const addListener = (emitter, eventName, listener) => {
-    emitter.on(eventName, listener);
-    return () => {
-        if (emitter.off) {
-            emitter.off(eventName, listener);
-        }
-        else if (emitter.removeListener) {
-            emitter.removeListener(eventName, listener);
-        }
-    };
-};
-const attachHandlersToEmitter = (emitter, browserWindow, windowInstance, handlerNames, filter) => {
+const attachHandlersToEmitter = (emitter, win, inst, names, filter) => {
     const cleanups = [];
-    for (const handlerName of handlerNames) {
-        if (!filter(handlerName)) {
+    for (const name of names) {
+        if (!filter(name))
             continue;
-        }
-        const handler = windowInstance[handlerName];
-        if (typeof handler !== "function") {
+        const h = inst[name];
+        if (typeof h !== "function")
             continue;
-        }
-        const eventName = toEventName(handlerName);
+        const evt = toEventName(name);
         const listener = (...args) => {
-            if (handler.length <= 1) {
-                handler.apply(windowInstance, [browserWindow]);
-            }
-            else {
-                handler.apply(windowInstance, [...args, browserWindow]);
-            }
+            h.length <= 1 ? h.apply(inst, [win]) : h.apply(inst, [...args, win]);
         };
-        cleanups.push(addListener(emitter, eventName, listener));
+        emitter.on(evt, listener);
+        cleanups.push(() => {
+            emitter.off
+                ? emitter.off(evt, listener)
+                : emitter.removeListener &&
+                    emitter.removeListener(evt, listener);
+        });
     }
     return cleanups;
 };
-export const attachWindowEventListeners = (browserWindow, windowInstance) => {
-    const entry = windowListeners.get(browserWindow);
-    if (entry?.instance === windowInstance) {
+export const attachWindowEventListeners = (win, inst) => {
+    const entry = windowListeners.get(win);
+    if (entry?.instance === inst)
         return;
-    }
-    if (entry) {
-        entry.cleanup.forEach((cleanup) => cleanup());
-    }
-    const handlerNames = getPrototypeMethodNames(windowInstance).filter(isHandlerName);
-    const windowCleanups = attachHandlersToEmitter(browserWindow, browserWindow, windowInstance, handlerNames, (name) => !isWebContentsHandler(name));
-    const webContentsCleanups = attachHandlersToEmitter(browserWindow.webContents, browserWindow, windowInstance, handlerNames, isWebContentsHandler);
-    windowListeners.set(browserWindow, {
-        instance: windowInstance,
-        cleanup: [...windowCleanups, ...webContentsCleanups],
+    if (entry)
+        entry.cleanup.forEach((c) => c());
+    const names = getPrototypeMethodNames(inst).filter((n) => n.startsWith("on"));
+    const isWebContents = (n) => n.startsWith("onWebContents");
+    const winCleanups = attachHandlersToEmitter(win, win, inst, names, (n) => !isWebContents(n));
+    const webCleanups = attachHandlersToEmitter(win.webContents, win, inst, names, isWebContents);
+    windowListeners.set(win, {
+        instance: inst,
+        cleanup: [...winCleanups, ...webCleanups],
     });
-    browserWindow.once("closed", () => {
-        const existing = windowListeners.get(browserWindow);
-        if (existing) {
-            existing.cleanup.forEach((cleanup) => cleanup());
-            windowListeners.delete(browserWindow);
+    win.once("closed", () => {
+        const e = windowListeners.get(win);
+        if (e) {
+            e.cleanup.forEach((c) => c());
+            windowListeners.delete(win);
         }
     });
 };

package/dist/@core/container.d.ts

@@ -22,10 +22,5 @@ export declare class Container {
     private instantiateClassProvider;
     private instantiateClassConstructor;
     private resolveDependencies;
-    private isProviderObject;
-    private isFactoryProvider;
-    private isClassProvider;
-    private isValueProvider;
-    private isExistingProvider;
 }
 export declare const container: Container;

package/dist/@core/container.js

@@ -96,17 +96,25 @@ export class Container {
         return undefined;
     }
     async instantiateProvider(moduleClass, token, provider) {
-        if (this.isFactoryProvider(provider)) {
+        const isObj = typeof provider === "object" &&
+            provider !== null &&
+            "provide" in provider;
+        if (isObj &&
+            "useFactory" in provider &&
+            typeof provider.useFactory === "function") {
             return this.instantiateFactoryProvider(moduleClass, token, provider);
         }
-        if (this.isClassProvider(provider)) {
+        if (isObj &&
+            "useClass" in provider &&
+            typeof provider.useClass === "function") {
             return this.instantiateClassProvider(moduleClass, token, provider);
         }
-        if (this.isValueProvider(provider)) {
-            this.instances.set(token, provider.useValue);
-            return provider.useValue;
+        if (isObj && "useValue" in provider) {
+            const val = provider.useValue;
+            this.instances.set(token, val);
+            return val;
         }
-        if (this.isExistingProvider(provider)) {
+        if (isObj && "useExisting" in provider) {
             const instance = await this.resolve(moduleClass, provider.useExisting);
             if (instance !== undefined) {
                 this.instances.set(token, instance);
@@ -142,24 +150,5 @@ export class Container {
     async resolveDependencies(moduleClass, dependencies) {
         return Promise.all(dependencies.map((dep) => this.resolve(moduleClass, dep)));
     }
-    isProviderObject(provider) {
-        return (typeof provider === "object" && provider !== null && "provide" in provider);
-    }
-    isFactoryProvider(provider) {
-        return (this.isProviderObject(provider) &&
-            "useFactory" in provider &&
-            typeof provider.useFactory === "function");
-    }
-    isClassProvider(provider) {
-        return (this.isProviderObject(provider) &&
-            "useClass" in provider &&
-            typeof provider.useClass === "function");
-    }
-    isValueProvider(provider) {
-        return this.isProviderObject(provider) && "useValue" in provider;
-    }
-    isExistingProvider(provider) {
-        return this.isProviderObject(provider) && "useExisting" in provider;
-    }
 }
 export const container = new Container();

package/dist/@core/control-window/create.js

@@ -3,79 +3,61 @@ import path from "node:path";
 import { cacheWindows } from "./cache.js";
 import { getWindow } from "./receive.js";
 import { getSettings } from "../bootstrap/settings.js";
-const createContentSecurityPolicy = (baseRestApi, isDev) => {
-    const csp = `
-    default-src 'self';
-    connect-src 'self' ${baseRestApi};
-    img-src * data:;
-    style-src 'self' 'unsafe-inline';
-    script-src 'self' ${isDev ? "'unsafe-inline'" : ""};
-  `
+const setupCSP = (base, dev) => {
+    const csp = `default-src 'self'; connect-src 'self' ${base}; img-src * data:; style-src 'self' 'unsafe-inline'; script-src 'self' ${dev ? "'unsafe-inline'" : ""};`
         .replace(/\s{2,}/g, " ")
         .trim();
-    return csp;
-};
-const setupContentSecurityPolicy = (baseRestApi, isDev) => {
-    const csp = createContentSecurityPolicy(baseRestApi, isDev);
-    session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
-        callback({
+    session.defaultSession.webRequest.onHeadersReceived((d, cb) => {
+        cb({
             responseHeaders: {
-                ...details.responseHeaders,
+                ...d.responseHeaders,
                 "Content-Security-Policy": [csp],
             },
         });
     });
 };
-const getAppPaths = (settings, isDev) => {
-    return {
-        ui: path.join(app.getAppPath(), `/${settings.folders.distRenderer}/index.html`),
-        preload: path.join(app.getAppPath(), isDev ? "." : "..", `/${settings.folders.distMain}/preload.cjs`),
-    };
-};
 export const createWindow = ({ hash, options, isCache, loadURL, }) => {
     const settings = getSettings();
     const isDev = process.env.NODE_ENV === "development";
-    const { ui: uiPath, preload: preloadPath } = getAppPaths(settings, isDev);
-    if (!settings.baseRestApi) {
+    const ui = path.join(app.getAppPath(), `/${settings.folders.distRenderer}/index.html`);
+    const preload = path.join(app.getAppPath(), isDev ? "." : "..", `/${settings.folders.distMain}/preload.cjs`);
+    if (!settings.baseRestApi)
         console.warn('Warning: You have to add an environment variable called "process.env.BASE_REST_API"!');
-    }
-    if (!settings.localhostPort) {
+    if (!settings.localhostPort)
         console.warn('Warning: You have to add an environment variable called "process.env.LOCALHOST_ELECTRON_SERVER_PORT"!');
-    }
     if (hash && isCache) {
-        const existingWindow = getWindow(hash);
-        if (existingWindow) {
-            existingWindow.show();
-            return existingWindow;
+        const existing = getWindow(hash);
+        if (existing) {
+            existing.show();
+            return existing;
         }
     }
-    const newWindow = new BrowserWindow({
+    const win = new BrowserWindow({
         ...options,
         webPreferences: {
-            preload: preloadPath,
+            preload,
             contextIsolation: true,
             nodeIntegration: false,
             ...options?.webPreferences,
         },
     });
-    if (isCache && !loadURL) {
-        setupContentSecurityPolicy(settings.baseRestApi, isDev);
-    }
+    if (isCache && !loadURL)
+        setupCSP(settings.baseRestApi, isDev);
     if (loadURL) {
-        newWindow.loadURL(loadURL);
+        win.loadURL(loadURL);
     }
     else if (isDev) {
-        newWindow.loadURL(`http://localhost:${settings.localhostPort}${hash ? `#${hash}` : ""}`);
+        win.loadURL(`http://localhost:${settings.localhostPort}${hash ? `#${hash}` : ""}`);
     }
     else if (hash) {
-        newWindow.loadFile(uiPath, { hash });
+        win.loadFile(ui, { hash });
     }
     if (hash && isCache) {
-        cacheWindows.set(hash, newWindow);
-        newWindow.on("close", (event) => {
-            event.preventDefault();
-            newWindow.hide();
+        cacheWindows.set(hash, win);
+        win.on("close", (e) => {
+            e.preventDefault();
+            win.hide();
         });
     }
-    return newWindow;
+    return win;
 };

package/dist/@core/errors/index.d.ts

@@ -1,15 +1,19 @@
-export declare class ModuleNotRegisteredError extends Error {
-    constructor(moduleName: string);
+declare class BaseError extends Error {
+    constructor(msg: string, name: string);
 }
-export declare class ProviderNotFoundError extends Error {
-    constructor(token: string, moduleName: string);
+export declare class ModuleNotRegisteredError extends BaseError {
+    constructor(m: string);
 }
-export declare class ModuleDecoratorMissingError extends Error {
-    constructor(moduleName: string);
+export declare class ProviderNotFoundError extends BaseError {
+    constructor(t: string, m: string);
 }
-export declare class InvalidProviderError extends Error {
-    constructor(moduleName: string);
+export declare class ModuleDecoratorMissingError extends BaseError {
+    constructor(m: string);
 }
-export declare class SettingsNotInitializedError extends Error {
+export declare class InvalidProviderError extends BaseError {
+    constructor(m: string);
+}
+export declare class SettingsNotInitializedError extends BaseError {
     constructor();
 }
+export {};

package/dist/@core/errors/index.js

@@ -1,30 +1,31 @@
-export class ModuleNotRegisteredError extends Error {
-    constructor(moduleName) {
-        super(`Module "${moduleName}" is not registered in the container.`);
-        this.name = "ModuleNotRegisteredError";
+class BaseError extends Error {
+    constructor(msg, name) {
+        super(msg);
+        this.name = name;
     }
 }
-export class ProviderNotFoundError extends Error {
-    constructor(token, moduleName) {
-        super(`Provider not found for token "${token}" in module "${moduleName}" or its imports.`);
-        this.name = "ProviderNotFoundError";
+export class ModuleNotRegisteredError extends BaseError {
+    constructor(m) {
+        super(`Module "${m}" is not registered in the container.`, "ModuleNotRegisteredError");
     }
 }
-export class ModuleDecoratorMissingError extends Error {
-    constructor(moduleName) {
-        super(`Module ${moduleName} does not have the @RgModule decorator`);
-        this.name = "ModuleDecoratorMissingError";
+export class ProviderNotFoundError extends BaseError {
+    constructor(t, m) {
+        super(`Provider not found for token "${t}" in module "${m}" or its imports.`, "ProviderNotFoundError");
     }
 }
-export class InvalidProviderError extends Error {
-    constructor(moduleName) {
-        super(`Invalid provider definition registered in module ${moduleName}`);
-        this.name = "InvalidProviderError";
+export class ModuleDecoratorMissingError extends BaseError {
+    constructor(m) {
+        super(`Module ${m} does not have the @RgModule decorator`, "ModuleDecoratorMissingError");
     }
 }
-export class SettingsNotInitializedError extends Error {
+export class InvalidProviderError extends BaseError {
+    constructor(m) {
+        super(`Invalid provider definition registered in module ${m}`, "InvalidProviderError");
+    }
+}
+export class SettingsNotInitializedError extends BaseError {
     constructor() {
-        super("App settings cache has not been initialized.");
-        this.name = "SettingsNotInitializedError";
+        super("App settings cache has not been initialized.", "SettingsNotInitializedError");
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_traeop_/electron-modular",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Core module system, DI container, IPC handlers, and window utilities for Electron main process.",
   "type": "module",
   "main": "./dist/index.js",