@devisfuture/electron-modular 1.1.10 → 1.1.11

package/dist/index.js

@@ -1,6 +1,4 @@
-// Container
 export * from "./@core/container.js";
-// Bootstrap
 export * from "./@core/bootstrap/bootstrap.js";
 export * from "./@core/bootstrap/initialize-module.js";
 export * from "./@core/bootstrap/instantiate-module.js";
@@ -9,26 +7,20 @@ 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/settings.js";
-// Initialize IPC
 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";
-// Control Window
 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";
-// Decorators
 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";
-// Types
 export * from "./@core/types/index.js";
-// Utils
 export * from "./@core/utils/dependency-tokens.js";
-// Errors
 export * from "./@core/errors/index.js";

package/package.json

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

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

@@ -1 +0,0 @@
-import "reflect-metadata/lite";

package/dist/@core/__tests__/container.test.js

@@ -1,409 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { describe, it, expect, beforeEach } from "vitest";
-import { Container } from "../container.js";
-import { Injectable } from "../decorators/injectable.js";
-import { Inject } from "../decorators/inject.js";
-import { ModuleNotRegisteredError, ProviderNotFoundError, } from "../errors/index.js";
-import "reflect-metadata/lite";
-describe("Container", () => {
-    let container;
-    beforeEach(() => {
-        container = new Container();
-    });
-    describe("addModule", () => {
-        it("should add a new module", () => {
-            class TestModule {
-            }
-            const result = container.addModule(TestModule, {
-                providers: [],
-                exports: [],
-            });
-            expect(result).toBe(true);
-            expect(container.hasModule(TestModule)).toBe(true);
-        });
-        it("should not add duplicate module", () => {
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [], exports: [] });
-            const result = container.addModule(TestModule, {
-                providers: [],
-                exports: [],
-            });
-            expect(result).toBe(false);
-        });
-        it("should store module exports", () => {
-            class TestModule {
-            }
-            const EXPORT_TOKEN = Symbol("export");
-            container.addModule(TestModule, {
-                providers: [],
-                exports: [EXPORT_TOKEN],
-            });
-            const exports = container.getModuleExports(TestModule);
-            expect(exports.has(EXPORT_TOKEN)).toBe(true);
-        });
-    });
-    describe("setModuleMetadata", () => {
-        it("should store module metadata", () => {
-            class TestModule {
-            }
-            class ImportedModule {
-            }
-            const metadata = {
-                imports: [ImportedModule],
-                providers: [],
-            };
-            container.setModuleMetadata(TestModule, metadata);
-            const retrieved = container.getModuleMetadata(TestModule);
-            expect(retrieved).toEqual(metadata);
-        });
-    });
-    describe("hasModule", () => {
-        it("should return true for registered module", () => {
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            expect(container.hasModule(TestModule)).toBe(true);
-        });
-        it("should return false for unregistered module", () => {
-            class TestModule {
-            }
-            expect(container.hasModule(TestModule)).toBe(false);
-        });
-    });
-    describe("addProvider", () => {
-        it("should add provider to module", () => {
-            class TestModule {
-            }
-            class TestService {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, TestService);
-            const provider = container.getProvider(TestModule, TestService);
-            expect(provider).toBe(TestService);
-        });
-        it("should throw error if module not registered", () => {
-            class TestModule {
-            }
-            class TestService {
-            }
-            expect(() => {
-                container.addProvider(TestModule, TestService);
-            }).toThrow(ModuleNotRegisteredError);
-        });
-        it("should add provider with instance", () => {
-            class TestModule {
-            }
-            const TOKEN = Symbol("token");
-            const instance = { value: "test" };
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, TOKEN, instance);
-            const provider = container.getProvider(TestModule, TOKEN);
-            expect(provider).toBe(instance);
-        });
-    });
-    describe("getProvider", () => {
-        it("should return undefined for unregistered module", () => {
-            class TestModule {
-            }
-            const TOKEN = Symbol("token");
-            const provider = container.getProvider(TestModule, TOKEN);
-            expect(provider).toBeUndefined();
-        });
-        it("should return undefined for non-existent provider", () => {
-            class TestModule {
-            }
-            const TOKEN = Symbol("token");
-            container.addModule(TestModule, { providers: [] });
-            const provider = container.getProvider(TestModule, TOKEN);
-            expect(provider).toBeUndefined();
-        });
-        it("should return provider", () => {
-            class TestModule {
-            }
-            class TestService {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, TestService);
-            const provider = container.getProvider(TestModule, TestService);
-            expect(provider).toBe(TestService);
-        });
-    });
-    describe("getModuleExports", () => {
-        it("should return empty set for unregistered module", () => {
-            class TestModule {
-            }
-            const exports = container.getModuleExports(TestModule);
-            expect(exports).toBeInstanceOf(Set);
-            expect(exports.size).toBe(0);
-        });
-        it("should return module exports", () => {
-            class TestModule {
-            }
-            const TOKEN1 = Symbol("token1");
-            const TOKEN2 = Symbol("token2");
-            container.addModule(TestModule, {
-                providers: [],
-                exports: [TOKEN1, TOKEN2],
-            });
-            const exports = container.getModuleExports(TestModule);
-            expect(exports.has(TOKEN1)).toBe(true);
-            expect(exports.has(TOKEN2)).toBe(true);
-        });
-    });
-    describe("registerInstance", () => {
-        it("should register singleton instance", () => {
-            const TOKEN = Symbol("token");
-            const instance = { value: "singleton" };
-            container.registerInstance(TOKEN, instance);
-            expect(true).toBe(true); // Instance registered
-        });
-    });
-    describe("resolve", () => {
-        it("should resolve class constructor provider", async () => {
-            let TestService = class TestService {
-                value = "test";
-            };
-            TestService = __decorate([
-                Injectable()
-            ], TestService);
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, TestService);
-            const instance = await container.resolve(TestModule, TestService);
-            expect(instance).toBeInstanceOf(TestService);
-            expect(instance?.value).toBe("test");
-        });
-        it("should resolve with dependencies", async () => {
-            let Dependency = class Dependency {
-                value = "dep";
-            };
-            Dependency = __decorate([
-                Injectable()
-            ], Dependency);
-            let TestService = class TestService {
-                dep;
-                constructor(dep) {
-                    this.dep = dep;
-                }
-            };
-            TestService = __decorate([
-                Injectable(),
-                __metadata("design:paramtypes", [Dependency])
-            ], TestService);
-            // Manually set metadata for testing
-            Reflect.defineMetadata("design:paramtypes", [Dependency], TestService);
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, Dependency);
-            container.addProvider(TestModule, TestService);
-            const instance = await container.resolve(TestModule, TestService);
-            expect(instance).toBeInstanceOf(TestService);
-            expect(instance?.dep).toBeInstanceOf(Dependency);
-        });
-        it("should resolve factory provider", async () => {
-            const factoryProvider = {
-                provide: "TEST_TOKEN",
-                useFactory: () => ({ value: "factory" }),
-            };
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, "TEST_TOKEN", factoryProvider);
-            const instance = await container.resolve(TestModule, "TEST_TOKEN");
-            expect(instance?.value).toBe("factory");
-        });
-        it("should resolve factory provider with dependencies", async () => {
-            let Dependency = class Dependency {
-                value = "dep";
-            };
-            Dependency = __decorate([
-                Injectable()
-            ], Dependency);
-            const factoryProvider = {
-                provide: "TEST_TOKEN",
-                useFactory: (dep) => ({ dep }),
-                inject: [Dependency],
-            };
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, Dependency);
-            container.addProvider(TestModule, "TEST_TOKEN", factoryProvider);
-            const instance = await container.resolve(TestModule, "TEST_TOKEN");
-            expect(instance?.dep).toBeInstanceOf(Dependency);
-        });
-        it("should resolve class provider", async () => {
-            let Implementation = class Implementation {
-                value = "impl";
-            };
-            Implementation = __decorate([
-                Injectable()
-            ], Implementation);
-            const classProvider = {
-                provide: "INTERFACE",
-                useClass: Implementation,
-            };
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, "INTERFACE", classProvider);
-            const instance = await container.resolve(TestModule, "INTERFACE");
-            expect(instance).toBeInstanceOf(Implementation);
-            expect(instance?.value).toBe("impl");
-        });
-        it("should resolve value provider", async () => {
-            const valueProvider = {
-                provide: "CONFIG",
-                useValue: { setting: "value" },
-            };
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, "CONFIG", valueProvider);
-            const instance = await container.resolve(TestModule, "CONFIG");
-            expect(instance?.setting).toBe("value");
-        });
-        it("should resolve existing provider", async () => {
-            let Service = class Service {
-                value = "service";
-            };
-            Service = __decorate([
-                Injectable()
-            ], Service);
-            const existingProvider = {
-                provide: "ALIAS",
-                useExisting: Service,
-            };
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, Service);
-            container.addProvider(TestModule, "ALIAS", existingProvider);
-            const instance = await container.resolve(TestModule, "ALIAS");
-            expect(instance).toBeInstanceOf(Service);
-        });
-        it("should cache resolved instances", async () => {
-            let TestService = class TestService {
-                value = Math.random();
-            };
-            TestService = __decorate([
-                Injectable()
-            ], TestService);
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, TestService);
-            const instance1 = await container.resolve(TestModule, TestService);
-            const instance2 = await container.resolve(TestModule, TestService);
-            expect(instance1).toBe(instance2);
-        });
-        it("should resolve from registered instances", async () => {
-            const TOKEN = Symbol("singleton");
-            const instance = { value: "singleton" };
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.registerInstance(TOKEN, instance);
-            const resolved = await container.resolve(TestModule, TOKEN);
-            expect(resolved).toBe(instance);
-        });
-        it("should throw error if provider not found", async () => {
-            class TestModule {
-            }
-            const TOKEN = Symbol("nonexistent");
-            container.addModule(TestModule, { providers: [] });
-            await expect(container.resolve(TestModule, TOKEN)).rejects.toThrow(ProviderNotFoundError);
-        });
-        it("should return undefined for module class token not found", async () => {
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            const result = await container.resolve(TestModule, TestModule);
-            expect(result).toBeUndefined();
-        });
-        it("should resolve from imports", async () => {
-            let SharedService = class SharedService {
-                value = "shared";
-            };
-            SharedService = __decorate([
-                Injectable()
-            ], SharedService);
-            class SharedModule {
-            }
-            class TestModule {
-            }
-            container.addModule(SharedModule, {
-                providers: [],
-                exports: [SharedService],
-            });
-            container.addProvider(SharedModule, SharedService);
-            container.addModule(TestModule, { providers: [] });
-            container.setModuleMetadata(TestModule, {
-                imports: [SharedModule],
-            });
-            const instance = await container.resolve(TestModule, SharedService);
-            expect(instance).toBeInstanceOf(SharedService);
-        });
-    });
-    describe("dependency injection with @Inject", () => {
-        it("should inject custom tokens", async () => {
-            const CONFIG_TOKEN = Symbol("config");
-            let TestService = class TestService {
-                config;
-                constructor(config) {
-                    this.config = config;
-                }
-            };
-            TestService = __decorate([
-                Injectable(),
-                __param(0, Inject(CONFIG_TOKEN)),
-                __metadata("design:paramtypes", [Object])
-            ], TestService);
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, CONFIG_TOKEN, { value: "config" });
-            container.addProvider(TestModule, TestService);
-            const instance = await container.resolve(TestModule, TestService);
-            expect(instance?.config).toEqual({ value: "config" });
-        });
-    });
-    describe("edge cases", () => {
-        it("should handle circular dependencies gracefully", async () => {
-            // Note: Actual circular dependency handling would need more complex implementation
-            // This test verifies basic behavior
-            let ServiceA = class ServiceA {
-                value = "a";
-            };
-            ServiceA = __decorate([
-                Injectable()
-            ], ServiceA);
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            container.addProvider(TestModule, ServiceA);
-            const instance = await container.resolve(TestModule, ServiceA);
-            expect(instance).toBeInstanceOf(ServiceA);
-        });
-        it("should handle empty providers array", async () => {
-            class TestModule {
-            }
-            container.addModule(TestModule, { providers: [] });
-            expect(container.hasModule(TestModule)).toBe(true);
-        });
-    });
-});

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

@@ -1 +0,0 @@
-import "reflect-metadata/lite";

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

@@ -1,131 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { bootstrapModules } from "../bootstrap.js";
-import { RgModule } from "../../decorators/rg-module.js";
-import { ModuleDecoratorMissingError } from "../../errors/index.js";
-import { container } from "../../container.js";
-import "reflect-metadata/lite";
-describe("bootstrapModules", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should throw error for module without @RgModule decorator", async () => {
-        class UnDecoratedModule {
-        }
-        await expect(bootstrapModules([UnDecoratedModule])).rejects.toThrow(ModuleDecoratorMissingError);
-    });
-    it("should bootstrap single module", async () => {
-        let TestModule = class TestModule {
-        };
-        TestModule = __decorate([
-            RgModule({
-                providers: [],
-            })
-        ], TestModule);
-        await bootstrapModules([TestModule]);
-        expect(container.hasModule(TestModule)).toBe(true);
-    });
-    it("should bootstrap multiple modules", async () => {
-        let Module1 = class Module1 {
-        };
-        Module1 = __decorate([
-            RgModule({
-                providers: [],
-            })
-        ], Module1);
-        let Module2 = class Module2 {
-        };
-        Module2 = __decorate([
-            RgModule({
-                providers: [],
-            })
-        ], Module2);
-        await bootstrapModules([Module1, Module2]);
-        expect(container.hasModule(Module1)).toBe(true);
-        expect(container.hasModule(Module2)).toBe(true);
-    });
-    it("should handle module with providers", async () => {
-        class Service {
-            value = "test";
-        }
-        let TestModule = class TestModule {
-        };
-        TestModule = __decorate([
-            RgModule({
-                providers: [Service],
-            })
-        ], TestModule);
-        await bootstrapModules([TestModule]);
-        const service = await container.resolve(TestModule, Service);
-        expect(service).toBeInstanceOf(Service);
-    });
-    it("should handle module with imports", async () => {
-        let ImportedModule = class ImportedModule {
-        };
-        ImportedModule = __decorate([
-            RgModule({
-                providers: [],
-            })
-        ], ImportedModule);
-        let MainModule = class MainModule {
-        };
-        MainModule = __decorate([
-            RgModule({
-                imports: [ImportedModule],
-                providers: [],
-            })
-        ], MainModule);
-        await bootstrapModules([MainModule]);
-        expect(container.hasModule(MainModule)).toBe(true);
-        expect(container.hasModule(ImportedModule)).toBe(true);
-    });
-    it("should handle empty modules array", async () => {
-        await expect(bootstrapModules([])).resolves.toBeUndefined();
-    });
-    it("should process modules in order", async () => {
-        const initOrder = [];
-        let Module1 = class Module1 {
-            constructor() {
-                initOrder.push("Module1");
-            }
-        };
-        Module1 = __decorate([
-            RgModule({
-                providers: [],
-            }),
-            __metadata("design:paramtypes", [])
-        ], Module1);
-        let Module2 = class Module2 {
-            constructor() {
-                initOrder.push("Module2");
-            }
-        };
-        Module2 = __decorate([
-            RgModule({
-                providers: [],
-            }),
-            __metadata("design:paramtypes", [])
-        ], Module2);
-        let Module3 = class Module3 {
-            constructor() {
-                initOrder.push("Module3");
-            }
-        };
-        Module3 = __decorate([
-            RgModule({
-                providers: [],
-            }),
-            __metadata("design:paramtypes", [])
-        ], Module3);
-        await bootstrapModules([Module1, Module2, Module3]);
-        expect(initOrder).toEqual(["Module1", "Module2", "Module3"]);
-    });
-});

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

@@ -1 +0,0 @@
-import "reflect-metadata/lite";