@devisfuture/electron-modular 1.2.17 → 1.2.19

package/README.md

@@ -725,6 +725,8 @@ These constraints guarantee clear module boundaries: lazy modules are activated
 
 #### Example: valid lazy module
 
+The Main Process
+
 ```typescript
 @RgModule({
   imports: [DatabaseCoreModule], // eager module
@@ -732,15 +734,39 @@ These constraints guarantee clear module boundaries: lazy modules are activated
   ipc: [AnalyticsIpc],
   lazy: {
     enabled: true,
-    trigger: "analytics:init",
+    trigger: "init-analytics-lazy",
   },
 })
 export class AnalyticsModule {}
 
 await bootstrapModules([AppModule, AnalyticsModule]);
+```
+
+The Renderer process in React
+
+```typescript
+import { useEffect, useCallback } from "react";
+
+....
 
-// Renderer side:
-await ipcRenderer.invoke("analytics:init");
+export const App = () => {
+
+  const initAnalyticsModule = useCallback(async () => {
+    const { initialized, name, error } = await window.electron.invoke("init-analytics-lazy");
+
+    if (initialized && error === undefined) {
+      console.log('Success!', 'Module:', name);
+    } else {
+      console.log('Error!', 'Module:', name, error.message);
+    }
+  }, []);
+
+  useEffect(() => {
+    initAnalyticsModule();
+  }, [initAnalyticsModule]);
+
+  return <>Home</>;
+};
 ```
 
 #### Example: invalid (lazy + exports)

package/dist/index.d.ts

@@ -1,28 +1,213 @@
-import "./reflect-metadata.js";
-export * from "./@core/container.js";
-export * from "./@core/bootstrap/bootstrap.js";
-export * from "./@core/bootstrap/initialize-module.js";
-export * from "./@core/bootstrap/instantiate-module.js";
-export * from "./@core/bootstrap/register-imports.js";
-export * from "./@core/bootstrap/register-ipc-handlers.js";
-export * from "./@core/bootstrap/register-providers.js";
-export * from "./@core/bootstrap/register-windows.js";
-export * from "./@core/bootstrap/register-lazy-module.js";
-export * from "./@core/bootstrap/settings.js";
-export * from "./@core/bootstrap/initialize-ipc/handlers.js";
-export * from "./@core/bootstrap/initialize-ipc/window-creator.js";
-export * from "./@core/bootstrap/initialize-ipc/window-event-listeners.js";
-export * from "./@core/bootstrap/initialize-ipc/window-instance-creator.js";
-export * from "./@core/control-window/cache.js";
-export * from "./@core/control-window/create.js";
-export * from "./@core/control-window/destroy.js";
-export * from "./@core/control-window/receive.js";
-export * from "./@core/control-window/types.js";
-export * from "./@core/decorators/inject.js";
-export * from "./@core/decorators/injectable.js";
-export * from "./@core/decorators/ipc-handler.js";
-export * from "./@core/decorators/rg-module.js";
-export * from "./@core/decorators/window-manager.js";
-export * from "./@core/types/index.js";
-export * from "./@core/utils/dependency-tokens.js";
-export * from "./@core/errors/index.js";
+import { BrowserWindowConstructorOptions, BrowserWindow } from 'electron';
+
+declare global {
+    namespace Reflect {
+        function defineMetadata(metadataKey: unknown, metadataValue: unknown, target: object, propertyKey?: PropertyKey): void;
+        function getOwnMetadata(metadataKey: unknown, target: object, propertyKey?: PropertyKey): unknown;
+        function getMetadata(metadataKey: unknown, target: object, propertyKey?: PropertyKey): unknown;
+        function hasOwnMetadata(metadataKey: unknown, target: object, propertyKey?: PropertyKey): boolean;
+        function hasMetadata(metadataKey: unknown, target: object, propertyKey?: PropertyKey): boolean;
+        function metadata(metadataKey: unknown, metadataValue: unknown): ClassDecorator & PropertyDecorator;
+    }
+}
+
+type Constructor<T = any> = new (...args: any[]) => T;
+
+type TParamsRoute = {
+    [key: string]: string;
+};
+type TParamsCreateWindow<N = string> = {
+    hash?: N;
+    isCache?: boolean;
+    paramsRoute?: TParamsRoute;
+    options?: BrowserWindowConstructorOptions;
+    loadURL?: string;
+};
+type TCache = {
+    [key in string]: BrowserWindow;
+};
+
+type TWindowCreate = (options?: TParamsCreateWindow) => Promise<BrowserWindow | undefined>;
+type TWindowFactory = {
+    create: TWindowCreate;
+};
+
+type TParamOnInit<N = string> = {
+    getWindow: (name?: N) => TWindowFactory;
+};
+type TIpcHandlerInterface = {
+    onInit?: (data: TParamOnInit) => void | Promise<void>;
+};
+
+type TProviderToken<T = any> = Constructor<T> | string | symbol;
+type TClassProvider<T = any> = {
+    provide: TProviderToken<T>;
+    useClass: Constructor<T>;
+    inject?: TProviderToken[];
+};
+type TFactoryProvider<T = any> = {
+    provide: TProviderToken<T>;
+    useFactory: (...args: any[]) => T;
+    inject?: TProviderToken[];
+};
+type TValueProvider<T = any> = {
+    provide: TProviderToken<T>;
+    useValue: T;
+};
+type TExistingProvider<T = any> = {
+    provide: TProviderToken<T>;
+    useExisting: TProviderToken<T>;
+};
+type TProvider<T = any> = Constructor<T> | TClassProvider<T> | TFactoryProvider<T> | TValueProvider<T> | TExistingProvider<T>;
+
+type TLazyConfig = {
+    enabled: true;
+    trigger: string;
+};
+type TLazyModuleResponse = {
+    initialized: boolean;
+    name: string;
+    error?: {
+        message: string;
+    };
+};
+
+type RgModuleMetadata = {
+    imports?: Constructor[];
+    ipc?: (new (...args: any[]) => TIpcHandlerInterface)[];
+    windows?: Constructor[];
+    providers?: TProvider[];
+    exports?: TProviderToken[];
+    lazy?: TLazyConfig;
+};
+
+declare class Container {
+    private readonly modules;
+    private readonly moduleMetadata;
+    private readonly instances;
+    private readonly resolutionCache;
+    addModule(moduleClass: Constructor, metadata: Pick<RgModuleMetadata, "exports" | "providers">): boolean;
+    setModuleMetadata(moduleClass: Constructor, metadata: RgModuleMetadata): void;
+    hasModule(moduleClass: Constructor): boolean;
+    private getCacheKey;
+    addProvider(moduleClass: Constructor, provider: TProviderToken, instance?: unknown): void;
+    getProvider<T = unknown>(moduleClass: Constructor, token: TProviderToken): T | undefined;
+    getModuleExports(moduleClass: Constructor): Set<TProviderToken>;
+    getModuleMetadata(moduleClass: Constructor): RgModuleMetadata | undefined;
+    registerInstance(token: TProviderToken, instance: unknown): void;
+    resolve<T>(moduleClass: Constructor, token: TProviderToken): Promise<T | undefined>;
+    private resolveFromImports;
+    private instantiateProvider;
+    private instantiateFactoryProvider;
+    private instantiateClassProvider;
+    private instantiateClassConstructor;
+    private resolveDependencies;
+}
+declare const container: Container;
+
+declare const bootstrapModules: (modulesClass: Constructor[]) => Promise<void>;
+
+declare const initializeModule: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;
+
+declare const instantiateModule: (moduleClass: Constructor) => Promise<unknown>;
+
+declare const registerImports: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;
+
+declare const registerIpcHandlers: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;
+
+declare const registerProviders: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;
+
+declare const registerWindows: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;
+
+declare const registerLazyModule: (moduleClass: Constructor, metadata: RgModuleMetadata) => void;
+
+type TFolderSettings = {
+    distRenderer: string;
+    distMain: string;
+};
+type TSettings = {
+    cspConnectSources?: string[];
+    localhostPort: string;
+    folders: TFolderSettings;
+};
+declare const initSettings: (options: TSettings) => void;
+declare const getSettings: () => TSettings;
+
+declare const initializeIpcHandlers: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;
+
+declare const createWindowWithParams: <W extends TParamsCreateWindow>(baseMetadata: W, params?: W) => BrowserWindow;
+
+type WindowManagerOptions = TParamsCreateWindow & {
+    options: BrowserWindowConstructorOptions;
+};
+type TWindowEventHandler = (...args: any[]) => void;
+type TWindowManagerWithHandlers = {
+    [key: `on${string}`]: TWindowEventHandler | undefined;
+};
+
+declare const attachWindowEventListeners: (win: BrowserWindow, inst: TWindowManagerWithHandlers) => void;
+
+declare const createWindowInstance: <T extends TWindowManagerWithHandlers>(moduleClass: Constructor, windowClass: Constructor<T>) => Promise<T | undefined>;
+
+declare const cacheWindows: Map<string, Electron.CrossProcessExports.BrowserWindow>;
+
+declare const createWindow: <N extends string>({ hash, options, isCache, loadURL, }: TParamsCreateWindow<N>) => BrowserWindow;
+
+declare const destroyWindows: () => void;
+
+declare const getWindow: <N extends string>(name: N) => BrowserWindow | undefined;
+
+type TInjectTokensMetadata = Record<number, TProviderToken>;
+declare const Inject: (token: TProviderToken) => ParameterDecorator;
+declare const getInjectedTokens: (target: Function) => TInjectTokensMetadata;
+
+declare const Injectable: () => ClassDecorator;
+
+declare const IpcHandler: () => ClassDecorator;
+
+declare const RgModule: (options: RgModuleMetadata) => ClassDecorator;
+
+declare const WindowManager: <P extends string>(options: TParamsCreateWindow<P>) => ClassDecorator;
+
+type TMetadataWindow = {
+    metadata: TParamsCreateWindow;
+    windowClass: Constructor;
+};
+
+declare const getDependencyTokens: (target: Constructor) => TProviderToken[];
+
+declare class BaseError extends Error {
+    constructor(msg: string, name: string);
+}
+declare class ModuleNotRegisteredError extends BaseError {
+    constructor(m: string);
+}
+declare class ProviderNotFoundError extends BaseError {
+    constructor(t: string, m: string);
+}
+declare class ModuleDecoratorMissingError extends BaseError {
+    constructor(m: string);
+}
+declare class InvalidProviderError extends BaseError {
+    constructor(m: string);
+}
+declare class SettingsNotInitializedError extends BaseError {
+    constructor();
+}
+declare class InvalidLazyTriggerError extends BaseError {
+    constructor(moduleName: string);
+}
+declare class DuplicateLazyTriggerError extends BaseError {
+    constructor(trigger: string, firstModule: string, secondModule: string);
+}
+declare class LazyModuleExportsNotAllowedError extends BaseError {
+    constructor(moduleName: string);
+}
+declare class LazyModuleCannotImportLazyModuleError extends BaseError {
+    constructor(moduleName: string, importedModuleName: string);
+}
+declare class EagerModuleCannotImportLazyModuleError extends BaseError {
+    constructor(moduleName: string, importedModuleName: string);
+}
+
+export { type Constructor, Container, DuplicateLazyTriggerError, EagerModuleCannotImportLazyModuleError, Inject, Injectable, InvalidLazyTriggerError, InvalidProviderError, IpcHandler, LazyModuleCannotImportLazyModuleError, LazyModuleExportsNotAllowedError, ModuleDecoratorMissingError, ModuleNotRegisteredError, ProviderNotFoundError, RgModule, type RgModuleMetadata, SettingsNotInitializedError, type TCache, type TClassProvider, type TExistingProvider, type TFactoryProvider, type TFolderSettings, type TIpcHandlerInterface, type TLazyConfig, type TLazyModuleResponse, type TMetadataWindow, type TParamOnInit, type TParamsCreateWindow, type TParamsRoute, type TProvider, type TProviderToken, type TSettings, type TValueProvider, type TWindowCreate, type TWindowFactory, type TWindowManagerWithHandlers, WindowManager, type WindowManagerOptions, attachWindowEventListeners, bootstrapModules, cacheWindows, container, createWindow, createWindowInstance, createWindowWithParams, destroyWindows, getDependencyTokens, getInjectedTokens, getSettings, getWindow, initSettings, initializeIpcHandlers, initializeModule, instantiateModule, registerImports, registerIpcHandlers, registerLazyModule, registerProviders, registerWindows };

package/dist/index.js

@@ -1,28 +1,2 @@
-import "./reflect-metadata.js";
-export * from "./@core/container.js";
-export * from "./@core/bootstrap/bootstrap.js";
-export * from "./@core/bootstrap/initialize-module.js";
-export * from "./@core/bootstrap/instantiate-module.js";
-export * from "./@core/bootstrap/register-imports.js";
-export * from "./@core/bootstrap/register-ipc-handlers.js";
-export * from "./@core/bootstrap/register-providers.js";
-export * from "./@core/bootstrap/register-windows.js";
-export * from "./@core/bootstrap/register-lazy-module.js";
-export * from "./@core/bootstrap/settings.js";
-export * from "./@core/bootstrap/initialize-ipc/handlers.js";
-export * from "./@core/bootstrap/initialize-ipc/window-creator.js";
-export * from "./@core/bootstrap/initialize-ipc/window-event-listeners.js";
-export * from "./@core/bootstrap/initialize-ipc/window-instance-creator.js";
-export * from "./@core/control-window/cache.js";
-export * from "./@core/control-window/create.js";
-export * from "./@core/control-window/destroy.js";
-export * from "./@core/control-window/receive.js";
-export * from "./@core/control-window/types.js";
-export * from "./@core/decorators/inject.js";
-export * from "./@core/decorators/injectable.js";
-export * from "./@core/decorators/ipc-handler.js";
-export * from "./@core/decorators/rg-module.js";
-export * from "./@core/decorators/window-manager.js";
-export * from "./@core/types/index.js";
-export * from "./@core/utils/dependency-tokens.js";
-export * from "./@core/errors/index.js";
+import {app,BrowserWindow,ipcMain,session}from'electron';import _ from'path';var b=new WeakMap,ee=(o,e)=>{let t=b.get(o);t===void 0&&(t=new Map,b.set(o,t));let r=t.get(e);return r===void 0&&(r=new Map,t.set(e,r)),r},D=(o,e)=>b.get(o)?.get(e);Reflect.defineMetadata===void 0&&(Reflect.defineMetadata=(o,e,t,r)=>{ee(t,r).set(o,e);});Reflect.getOwnMetadata===void 0&&(Reflect.getOwnMetadata=(o,e,t)=>D(e,t)?.get(o));Reflect.getMetadata===void 0&&(Reflect.getMetadata=(o,e,t)=>{let r=e;for(;r!==null;){let n=Reflect.getOwnMetadata(o,r,t);if(n!==void 0)return n;r=Object.getPrototypeOf(r);}});Reflect.hasOwnMetadata===void 0&&(Reflect.hasOwnMetadata=(o,e,t)=>D(e,t)?.has(o)??false);Reflect.hasMetadata===void 0&&(Reflect.hasMetadata=(o,e,t)=>{let r=e;for(;r!==null;){if(Reflect.hasOwnMetadata(o,r,t))return  true;r=Object.getPrototypeOf(r);}return  false});Reflect.metadata===void 0&&(Reflect.metadata=(o,e)=>(t,r)=>{Reflect.defineMetadata(o,e,t,r);});var I="RgInjectTokens",me=o=>(e,t,r)=>{if(t!==void 0)return;let n=Reflect.getMetadata(I,e)??{};n[r]=o,Reflect.defineMetadata(I,n,e);},S=o=>Reflect.getMetadata(I,o)??{};var z=new WeakMap,l=o=>{let e=z.get(o);if(e!==void 0)return e;let t=Reflect.getMetadata("design:paramtypes",o)??[],r=S(o),n=Object.keys(r).map(Number),s=Math.max(t.length-1,...n,-1);if(s<0)return z.set(o,t),t;let a=Array.from({length:s+1},(d,c)=>r[c]??t[c]);return z.set(o,a),a};var p=class extends Error{constructor(e,t){super(e),this.name=t;}},y=class extends p{constructor(e){super(`Module "${e}" is not registered in the container.`,"ModuleNotRegisteredError");}},g=class extends p{constructor(e,t){super(`Provider not found for token "${e}" in module "${t}" or its imports.`,"ProviderNotFoundError");}},w=class extends p{constructor(e){super(`Module ${e} does not have the @RgModule decorator`,"ModuleDecoratorMissingError");}},M=class extends p{constructor(e){super(`Invalid provider definition registered in module ${e}`,"InvalidProviderError");}},T=class extends p{constructor(){super("App settings cache has not been initialized.","SettingsNotInitializedError");}},f=class extends p{constructor(e){super(`Invalid lazy trigger in module "${e}". "lazy.trigger" must be a non-empty string.`,"InvalidLazyTriggerError");}},P=class extends p{constructor(e,t,r){super(`Duplicate lazy trigger "${e}" detected in modules "${t}" and "${r}". Each lazy module must use a unique trigger.`,"DuplicateLazyTriggerError");}},v=class extends p{constructor(e){super(`Invalid lazy module "${e}". Lazy modules cannot declare exports.`,"LazyModuleExportsNotAllowedError");}},h=class extends p{constructor(e,t){super(`Invalid lazy module "${e}". It cannot import lazy module "${t}". Lazy modules can only import eager modules.`,"LazyModuleCannotImportLazyModuleError");}},x=class extends p{constructor(e,t){super(`Invalid eager module "${e}". It cannot import lazy module "${t}". Eager modules must import only eager modules.`,"EagerModuleCannotImportLazyModuleError");}};var E=class{modules=new Map;moduleMetadata=new Map;instances=new Map;resolutionCache=new Map;addModule(e,t){return this.modules.has(e)?false:(this.modules.set(e,{providers:new Map,exports:new Set(t.exports??[])}),true)}setModuleMetadata(e,t){this.moduleMetadata.set(e,t);}hasModule(e){return this.modules.has(e)}getCacheKey(e,t){let r=typeof t=="string"||typeof t=="symbol"?String(t):t.name;return `${e.name}:${r}`}addProvider(e,t,r){let n=this.modules.get(e);if(!n)throw new y(e.name);n.providers.set(t,r??t);}getProvider(e,t){let r=this.modules.get(e);if(r)return r.providers.get(t)}getModuleExports(e){return this.modules.get(e)?.exports??new Set}getModuleMetadata(e){return this.moduleMetadata.get(e)}registerInstance(e,t){this.instances.set(e,t);}async resolve(e,t){let r=this.getCacheKey(e,t);if(this.resolutionCache.has(r))return this.resolutionCache.get(r);if(this.instances.has(t)){let a=this.instances.get(t);return this.resolutionCache.set(r,a),a}let n=this.getProvider(e,t);if(!n){let a=await this.resolveFromImports(e,t);if(a!==void 0)return this.resolutionCache.set(r,a),a;if(t!==e)throw new g(String(t),e.name);return}let s=await this.instantiateProvider(e,t,n);return s!==void 0&&this.resolutionCache.set(r,s),s}async resolveFromImports(e,t){let r=this.getModuleMetadata(e);if(r?.imports){for(let n of r.imports)if(this.getModuleExports(n).has(t)&&this.getProvider(n,t)!==void 0)return this.resolve(n,t)}}async instantiateProvider(e,t,r){let n=typeof r=="object"&&r!==null&&"provide"in r;if(n&&"useFactory"in r&&typeof r.useFactory=="function")return this.instantiateFactoryProvider(e,t,r);if(n&&"useClass"in r&&typeof r.useClass=="function")return this.instantiateClassProvider(e,t,r);if(n&&"useValue"in r){let s=r.useValue;return this.instances.set(t,s),s}if(n&&"useExisting"in r){let s=await this.resolve(e,r.useExisting);return s!==void 0&&this.instances.set(t,s),s}return typeof r=="function"?this.instantiateClassConstructor(e,t,r):r}async instantiateFactoryProvider(e,t,r){let n=r.inject??[],s=await this.resolveDependencies(e,n),a=r.useFactory(...s);return this.instances.set(t,a),a}async instantiateClassProvider(e,t,r){let n=r.inject??l(r.useClass),s=await this.resolveDependencies(e,n),a=new r.useClass(...s);return this.instances.set(t,a),a}async instantiateClassConstructor(e,t,r){let n=l(r),s=await this.resolveDependencies(e,n),a=new r(...s);return this.instances.set(t,a),a}async resolveDependencies(e,t){return Promise.all(t.map(r=>this.resolve(e,r)))}},i=new E;var j=async o=>{let e=l(o),t=await Promise.all(e.map(n=>i.resolve(o,n))),r=new o(...t);return i.registerInstance(o,r),r};var te=o=>typeof o=="object"&&o!==null&&"provide"in o,K=async(o,e)=>{if(e.providers)for(let t of e.providers){if(typeof t=="function"){i.addProvider(o,t);continue}if(te(t)){i.addProvider(o,t.provide,t);continue}throw new M(o.name)}};var L=async(o,e)=>{if(e.imports)for(let t of e.imports){let r=Reflect.getMetadata("RgModule",t);if(r?.lazy?.enabled&&!e.lazy?.enabled)throw new x(o.name,t.name);r&&await m(t,r);}};var $=async(o,e)=>{if(e.windows)for(let t of e.windows){let r=Reflect.getMetadata("WindowManager",t);r?.hash&&i.addProvider(o,r.hash,{metadata:r,windowClass:t});}};var F=async(o,e)=>{if(e.ipc)for(let t of e.ipc)i.addProvider(o,t);};var W=(o,e)=>{if(e.lazy?.enabled){if((e.exports?.length??0)>0)throw new v(o.name);if(e.imports?.length){for(let t of e.imports)if(Reflect.getMetadata("RgModule",t)?.lazy?.enabled)throw new h(o.name,t.name)}}};var m=async(o,e)=>{W(o,e);let t=i.addModule(o,e);i.setModuleMetadata(o,e),t&&await Promise.all([K(o,e),L(o,e),$(o,e),F(o,e)]);};var C=new Map;var H=o=>{let e=C.get(o);if(!(!e||typeof e=="boolean"||e.isDestroyed()))return e};var A="settings",N=new Map,Ge=o=>{N.set(A,o);},B=()=>{let o=N.get(A);if(!o)throw new T;return o};var ne=(o,e)=>{let r=`default-src 'self'; connect-src 'self'${o.length>0?` ${o.join(" ")}`:""}; img-src * data:; style-src 'self' 'unsafe-inline'; script-src 'self' ${e?"'unsafe-inline'":""};`.replace(/\s{2,}/g," ").trim();session.defaultSession.webRequest.onHeadersReceived((n,s)=>{s({responseHeaders:{...n.responseHeaders,"Content-Security-Policy":[r]}});});},Y=({hash:o,options:e,isCache:t,loadURL:r})=>{let n=B(),s=process.env.NODE_ENV==="development",a=_.join(app.getAppPath(),`/${n.folders.distRenderer}/index.html`),d=_.join(app.getAppPath(),s?".":"..",`/${n.folders.distMain}/preload.cjs`);if(n.localhostPort||console.warn('Warning: You have to add an environment variable for example called "process.env.LOCALHOST_ELECTRON_SERVER_PORT"!'),o&&t){let u=H(o);if(u)return u.show(),u}let c=new BrowserWindow({...e,webPreferences:{preload:d,contextIsolation:true,nodeIntegration:false,...e?.webPreferences}});return t&&!r&&n.cspConnectSources&&ne(n.cspConnectSources,s),r?c.loadURL(r):s?c.loadURL(`http://localhost:${n.localhostPort}${o?`#${o}`:""}`):o&&c.loadFile(a,{hash:o}),o&&t&&(C.set(o,c),c.on("close",u=>{u.preventDefault(),c.hide();})),c};var Z=o=>typeof o=="object"&&o!==null&&!Array.isArray(o)&&Object.prototype.toString.call(o)==="[object Object]",O=(o,e)=>{let t={...o};for(let[r,n]of Object.entries(e))if(Z(n)){let s=t[r];t[r]=Z(s)?O(s,n):O({},n);}else t[r]=n;return t},q=(o,e)=>{let t=e!==void 0?O(o,e):o;return Y(t)};var G=async(o,e)=>{if(!e)return;let t=l(e),r=await Promise.all(t.map(n=>i.resolve(o,n)));return new e(...r)};var k=new WeakMap,se=o=>{let e=new Set,t=Object.getPrototypeOf(o);for(;t&&t!==Object.prototype;)Object.getOwnPropertyNames(t).forEach(r=>r!=="constructor"&&e.add(r)),t=Object.getPrototypeOf(t);return Array.from(e)},ae=o=>o.replace(/^(onWindow|onWebContents|on)/,"").replace(/([a-z0-9])([A-Z])/g,"$1-$2").replace(/([A-Z])([A-Z][a-z])/g,"$1-$2").toLowerCase(),J=(o,e,t,r,n)=>{let s=[];for(let a of r){if(!n(a))continue;let d=t[a];if(typeof d!="function")continue;let c=ae(a),u=(...X)=>{d.length<=1?d.apply(t,[e]):d.apply(t,[...X,e]);};o.on(c,u),s.push(()=>{o.off?o.off(c,u):o.removeListener&&o.removeListener(c,u);});}return s},Q=(o,e)=>{let t=k.get(o);if(t?.instance===e)return;t&&t.cleanup.forEach(d=>d());let r=se(e).filter(d=>d.startsWith("on")),n=d=>d.startsWith("onWebContents"),s=J(o,o,e,r,d=>!n(d)),a=J(o.webContents,o,e,r,n);k.set(o,{instance:e,cleanup:[...s,...a]}),o.once("closed",()=>{let d=k.get(o);d&&(d.cleanup.forEach(c=>c()),k.delete(o));});};var ie=(o,e)=>!e?.metadata?.options||!e.metadata.hash||!e.windowClass?{create:async()=>{}}:{create:async t=>{let r=q(e.metadata,t),n=await G(o,e.windowClass);if(r&&n)return Q(r,n),r}},de=o=>e=>{if(!e)return {create:async()=>{}};let t=i.getProvider(o,e);return ie(o,t)},R=async(o,e)=>{if(!e.ipc)return;let t=de(o);for(let r of e.ipc){let n=await i.resolve(o,r);n?.onInit&&await n.onInit({getWindow:t});}};var pe=(o,e)=>{let t=e.lazy?.trigger;if(typeof t!="string"||t.trim().length===0)throw new f(o.name);return t.trim()},U=(o,e)=>{let t=pe(o,e),r=null;ipcMain.handle(t,async()=>r||(r=(async()=>{try{return await m(o,e),await j(o),await i.resolve(o,o),e.windows?.length&&!e.ipc?.length&&console.warn(`Warning: Window(s) declared in module "${o.name}" but no IPC handlers found to manage them.`),await R(o,e),{initialized:!0,name:t}}catch(n){return r=null,{initialized:false,name:t,error:{message:n instanceof Error?n.message:String(n)}}}})(),r));};var ue=(o,e)=>{let t=e.lazy?.trigger;if(typeof t!="string"||t.trim().length===0)throw new f(o.name);return t.trim()},Rt=async o=>{let e=new Map;for(let t of o){let r=Reflect.getMetadata("RgModule",t);if(!r)throw new w(t.name);if(W(t,r),r.lazy?.enabled){let n=ue(t,r),s=e.get(n);if(s)throw new P(n,s,t.name);e.set(n,t.name),U(t,r);continue}await m(t,r),await j(t),await i.resolve(t,t),r.windows?.length&&!r.ipc?.length&&console.warn(`Warning: Window(s) declared in module "${t.name}" but no IPC handlers found to manage them.`),await R(t,r);}};var zt=()=>{let o=BrowserWindow.getAllWindows();for(let e of o)e.isDestroyed()||e.destroy();};var Dt=()=>o=>{Reflect.defineMetadata("Injectable",true,o);};var Lt=()=>o=>{Reflect.defineMetadata("IpcHandler",true,o);};var Ht=o=>e=>{Reflect.defineMetadata("RgModule",o,e);};var Bt=o=>e=>{Reflect.defineMetadata("WindowManager",o,e);};
+export{E as Container,P as DuplicateLazyTriggerError,x as EagerModuleCannotImportLazyModuleError,me as Inject,Dt as Injectable,f as InvalidLazyTriggerError,M as InvalidProviderError,Lt as IpcHandler,h as LazyModuleCannotImportLazyModuleError,v as LazyModuleExportsNotAllowedError,w as ModuleDecoratorMissingError,y as ModuleNotRegisteredError,g as ProviderNotFoundError,Ht as RgModule,T as SettingsNotInitializedError,Bt as WindowManager,Q as attachWindowEventListeners,Rt as bootstrapModules,C as cacheWindows,i as container,Y as createWindow,G as createWindowInstance,q as createWindowWithParams,zt as destroyWindows,l as getDependencyTokens,S as getInjectedTokens,B as getSettings,H as getWindow,Ge as initSettings,R as initializeIpcHandlers,m as initializeModule,j as instantiateModule,L as registerImports,F as registerIpcHandlers,U as registerLazyModule,K as registerProviders,$ as registerWindows};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devisfuture/electron-modular",
-  "version": "1.2.17",
+  "version": "1.2.19",
   "description": "Core module system, DI container, IPC handlers, and window utilities for Electron main process.",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,9 +22,12 @@
   "publishConfig": {
     "access": "public"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./src/reflect-metadata.ts",
+    "./dist/index.js"
+  ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsup",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:ui": "vitest --ui",
@@ -42,6 +45,7 @@
     "@vitest/ui": "^2.1.9",
     "electron": "^36.4.0",
     "reflect-metadata": "^0.2.2",
+    "tsup": "^8.5.0",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8"
   },

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

@@ -1,2 +0,0 @@
-import type { Constructor } from "../types/constructor.js";
-export declare const bootstrapModules: (modulesClass: Constructor[]) => Promise<void>;

package/dist/@core/bootstrap/bootstrap.js

@@ -1,41 +0,0 @@
-import { ModuleDecoratorMissingError, DuplicateLazyTriggerError, InvalidLazyTriggerError, } from "../errors/index.js";
-import { instantiateModule } from "./instantiate-module.js";
-import { initializeModule } from "./initialize-module.js";
-import { container } from "../container.js";
-import { initializeIpcHandlers } from "./initialize-ipc/handlers.js";
-import { registerLazyModule } from "./register-lazy-module.js";
-import { validateLazyConstraints } from "./validate-lazy-constraints.js";
-const getValidLazyTrigger = (moduleClass, metadata) => {
-    const trigger = metadata.lazy?.trigger;
-    if (typeof trigger !== "string" || trigger.trim().length === 0) {
-        throw new InvalidLazyTriggerError(moduleClass.name);
-    }
-    return trigger.trim();
-};
-export const bootstrapModules = async (modulesClass) => {
-    const lazyTriggerRegistry = new Map();
-    for (const moduleClass of modulesClass) {
-        const metadata = Reflect.getMetadata("RgModule", moduleClass);
-        if (!metadata) {
-            throw new ModuleDecoratorMissingError(moduleClass.name);
-        }
-        validateLazyConstraints(moduleClass, metadata);
-        if (metadata.lazy?.enabled) {
-            const trigger = getValidLazyTrigger(moduleClass, metadata);
-            const existingModule = lazyTriggerRegistry.get(trigger);
-            if (existingModule) {
-                throw new DuplicateLazyTriggerError(trigger, existingModule, moduleClass.name);
-            }
-            lazyTriggerRegistry.set(trigger, moduleClass.name);
-            registerLazyModule(moduleClass, metadata);
-            continue;
-        }
-        await initializeModule(moduleClass, metadata);
-        await instantiateModule(moduleClass);
-        await container.resolve(moduleClass, moduleClass);
-        if (metadata.windows?.length && !metadata.ipc?.length) {
-            console.warn(`Warning: Window(s) declared in module "${moduleClass.name}" but no IPC handlers found to manage them.`);
-        }
-        await initializeIpcHandlers(moduleClass, metadata);
-    }
-};

package/dist/@core/bootstrap/initialize-ipc/handlers.d.ts

@@ -1,3 +0,0 @@
-import type { Constructor } from "../../types/constructor.js";
-import type { RgModuleMetadata } from "../../types/module-metadata.js";
-export declare const initializeIpcHandlers: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;

package/dist/@core/bootstrap/initialize-ipc/handlers.js

@@ -1,47 +0,0 @@
-import { container } from "../../container.js";
-import { createWindowWithParams } from "./window-creator.js";
-import { createWindowInstance } from "./window-instance-creator.js";
-import { attachWindowEventListeners } from "./window-event-listeners.js";
-const createWindowFactory = (moduleClass, windowMetadata) => {
-    if (!windowMetadata?.metadata?.options ||
-        !windowMetadata.metadata.hash ||
-        !windowMetadata.windowClass) {
-        return {
-            create: async () => undefined,
-        };
-    }
-    return {
-        create: async (params) => {
-            const browserWindow = createWindowWithParams(windowMetadata.metadata, params);
-            const windowInstance = await createWindowInstance(moduleClass, windowMetadata.windowClass);
-            if (browserWindow && windowInstance) {
-                attachWindowEventListeners(browserWindow, windowInstance);
-                return browserWindow;
-            }
-            return undefined;
-        },
-    };
-};
-const createGetWindowFunction = (moduleClass) => {
-    return (name) => {
-        if (!name) {
-            return {
-                create: async () => undefined,
-            };
-        }
-        const windowMetadata = container.getProvider(moduleClass, name);
-        return createWindowFactory(moduleClass, windowMetadata);
-    };
-};
-export const initializeIpcHandlers = async (moduleClass, metadata) => {
-    if (!metadata.ipc) {
-        return;
-    }
-    const getWindow = createGetWindowFunction(moduleClass);
-    for (const ipcClass of metadata.ipc) {
-        const ipcInstance = await container.resolve(moduleClass, ipcClass);
-        if (ipcInstance?.onInit) {
-            await ipcInstance.onInit({ getWindow });
-        }
-    }
-};

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

@@ -1,3 +0,0 @@
-import type { BrowserWindow } from "electron";
-import type { TParamsCreateWindow } from "../../control-window/types.js";
-export declare const createWindowWithParams: <W extends TParamsCreateWindow>(baseMetadata: W, params?: W) => BrowserWindow;

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

@@ -1,28 +0,0 @@
-import { createWindow } from "../../control-window/create.js";
-const isPlainObject = (value) => {
-    return (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        Object.prototype.toString.call(value) === "[object Object]");
-};
-const mergeDeep = (target, source) => {
-    const output = { ...target };
-    for (const [key, value] of Object.entries(source)) {
-        if (isPlainObject(value)) {
-            const current = output[key];
-            output[key] = isPlainObject(current)
-                ? mergeDeep(current, value)
-                : mergeDeep({}, value);
-        }
-        else {
-            output[key] = value;
-        }
-    }
-    return output;
-};
-export const createWindowWithParams = (baseMetadata, params) => {
-    const mergedSettings = params !== undefined
-        ? mergeDeep(baseMetadata, params)
-        : baseMetadata;
-    return createWindow(mergedSettings);
-};

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

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

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

@@ -1,61 +0,0 @@
-const windowListeners = new WeakMap();
-const getPrototypeMethodNames = (instance) => {
-    const names = new Set();
-    let proto = Object.getPrototypeOf(instance);
-    while (proto && proto !== Object.prototype) {
-        Object.getOwnPropertyNames(proto).forEach((n) => n !== "constructor" && names.add(n));
-        proto = Object.getPrototypeOf(proto);
-    }
-    return Array.from(names);
-};
-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 attachHandlersToEmitter = (emitter, win, inst, names, filter) => {
-    const cleanups = [];
-    for (const name of names) {
-        if (!filter(name))
-            continue;
-        const h = inst[name];
-        if (typeof h !== "function")
-            continue;
-        const evt = toEventName(name);
-        const listener = (...args) => {
-            h.length <= 1 ? h.apply(inst, [win]) : h.apply(inst, [...args, win]);
-        };
-        emitter.on(evt, listener);
-        cleanups.push(() => {
-            emitter.off
-                ? emitter.off(evt, listener)
-                : emitter.removeListener &&
-                    emitter.removeListener(evt, listener);
-        });
-    }
-    return cleanups;
-};
-export const attachWindowEventListeners = (win, inst) => {
-    const entry = windowListeners.get(win);
-    if (entry?.instance === inst)
-        return;
-    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],
-    });
-    win.once("closed", () => {
-        const e = windowListeners.get(win);
-        if (e) {
-            e.cleanup.forEach((c) => c());
-            windowListeners.delete(win);
-        }
-    });
-};

package/dist/@core/bootstrap/initialize-ipc/window-instance-creator.d.ts

@@ -1,3 +0,0 @@
-import type { Constructor } from "../../types/constructor.js";
-import type { TWindowManagerWithHandlers } from "../../types/window-manager.js";
-export declare const createWindowInstance: <T extends TWindowManagerWithHandlers>(moduleClass: Constructor, windowClass: Constructor<T>) => Promise<T | undefined>;

package/dist/@core/bootstrap/initialize-ipc/window-instance-creator.js

@@ -1,10 +0,0 @@
-import { container } from "../../container.js";
-import { getDependencyTokens } from "../../utils/dependency-tokens.js";
-export const createWindowInstance = async (moduleClass, windowClass) => {
-    if (!windowClass) {
-        return undefined;
-    }
-    const dependenciesTypes = getDependencyTokens(windowClass);
-    const resolvedDependencies = await Promise.all(dependenciesTypes.map((depType) => container.resolve(moduleClass, depType)));
-    return new windowClass(...resolvedDependencies);
-};

package/dist/@core/bootstrap/initialize-module.d.ts

@@ -1,3 +0,0 @@
-import type { RgModuleMetadata } from "../types/module-metadata.js";
-import type { Constructor } from "../types/constructor.js";
-export declare const initializeModule: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;

package/dist/@core/bootstrap/initialize-module.js

@@ -1,20 +0,0 @@
-import { container } from "../container.js";
-import { registerProviders } from "./register-providers.js";
-import { registerImports } from "./register-imports.js";
-import { registerWindows } from "./register-windows.js";
-import { registerIpcHandlers } from "./register-ipc-handlers.js";
-import { validateLazyConstraints } from "./validate-lazy-constraints.js";
-export const initializeModule = async (moduleClass, metadata) => {
-    validateLazyConstraints(moduleClass, metadata);
-    const isNewModule = container.addModule(moduleClass, metadata);
-    container.setModuleMetadata(moduleClass, metadata);
-    if (!isNewModule) {
-        return;
-    }
-    await Promise.all([
-        registerProviders(moduleClass, metadata),
-        registerImports(moduleClass, metadata),
-        registerWindows(moduleClass, metadata),
-        registerIpcHandlers(moduleClass, metadata),
-    ]);
-};

package/dist/@core/bootstrap/instantiate-module.d.ts

@@ -1,2 +0,0 @@
-import type { Constructor } from "../types/constructor.js";
-export declare const instantiateModule: (moduleClass: Constructor) => Promise<unknown>;

package/dist/@core/bootstrap/instantiate-module.js

@@ -1,9 +0,0 @@
-import { container } from "../container.js";
-import { getDependencyTokens } from "../utils/dependency-tokens.js";
-export const instantiateModule = async (moduleClass) => {
-    const dependencies = getDependencyTokens(moduleClass);
-    const resolvedDependencies = await Promise.all(dependencies.map((dependency) => container.resolve(moduleClass, dependency)));
-    const instance = new moduleClass(...resolvedDependencies);
-    container.registerInstance(moduleClass, instance);
-    return instance;
-};

package/dist/@core/bootstrap/register-imports.d.ts

@@ -1,3 +0,0 @@
-import type { RgModuleMetadata } from "../types/module-metadata.js";
-import type { Constructor } from "../types/constructor.js";
-export declare const registerImports: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;