@devisfuture/electron-modular 1.1.9 → 1.1.10

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

@@ -0,0 +1,174 @@
+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, beforeEach } from "vitest";
+import { instantiateModule } from "../instantiate-module.js";
+import { container } from "../../container.js";
+import { Injectable } from "../../decorators/injectable.js";
+import "reflect-metadata/lite";
+describe("instantiateModule", () => {
+    beforeEach(() => {
+        // Each test will create its own module
+    });
+    it("should instantiate module with no dependencies", async () => {
+        let SimpleModule = class SimpleModule {
+            value = "simple";
+        };
+        SimpleModule = __decorate([
+            Injectable()
+        ], SimpleModule);
+        container.addModule(SimpleModule, { providers: [] });
+        const instance = await instantiateModule(SimpleModule);
+        expect(instance).toBeInstanceOf(SimpleModule);
+        expect(instance.value).toBe("simple");
+    });
+    it("should instantiate module with dependencies", async () => {
+        let Dependency = class Dependency {
+            value = "dep";
+        };
+        Dependency = __decorate([
+            Injectable()
+        ], Dependency);
+        let ModuleWithDeps = class ModuleWithDeps {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+        };
+        ModuleWithDeps = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [Dependency])
+        ], ModuleWithDeps);
+        Reflect.defineMetadata("design:paramtypes", [Dependency], ModuleWithDeps);
+        container.addModule(ModuleWithDeps, { providers: [] });
+        container.addProvider(ModuleWithDeps, Dependency);
+        const instance = await instantiateModule(ModuleWithDeps);
+        expect(instance).toBeInstanceOf(ModuleWithDeps);
+        expect(instance.dep).toBeInstanceOf(Dependency);
+    });
+    it("should register instantiated module in container", async () => {
+        let TestModule = class TestModule {
+            id = Math.random();
+        };
+        TestModule = __decorate([
+            Injectable()
+        ], TestModule);
+        container.addModule(TestModule, { providers: [] });
+        const instance1 = await instantiateModule(TestModule);
+        const instance2 = await container.resolve(TestModule, TestModule);
+        expect(instance1).toBe(instance2);
+    });
+    it("should resolve multiple dependencies", async () => {
+        let Dep1 = class Dep1 {
+            value = "dep1";
+        };
+        Dep1 = __decorate([
+            Injectable()
+        ], Dep1);
+        let Dep2 = class Dep2 {
+            value = "dep2";
+        };
+        Dep2 = __decorate([
+            Injectable()
+        ], Dep2);
+        let ModuleWithMultipleDeps = class ModuleWithMultipleDeps {
+            dep1;
+            dep2;
+            constructor(dep1, dep2) {
+                this.dep1 = dep1;
+                this.dep2 = dep2;
+            }
+        };
+        ModuleWithMultipleDeps = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [Dep1,
+                Dep2])
+        ], ModuleWithMultipleDeps);
+        Reflect.defineMetadata("design:paramtypes", [Dep1, Dep2], ModuleWithMultipleDeps);
+        container.addModule(ModuleWithMultipleDeps, { providers: [] });
+        container.addProvider(ModuleWithMultipleDeps, Dep1);
+        container.addProvider(ModuleWithMultipleDeps, Dep2);
+        const instance = await instantiateModule(ModuleWithMultipleDeps);
+        expect(instance.dep1).toBeInstanceOf(Dep1);
+        expect(instance.dep2).toBeInstanceOf(Dep2);
+    });
+    it("should handle module with constructor logic", async () => {
+        let ModuleWithLogic = class ModuleWithLogic {
+            initialized = false;
+            constructor() {
+                this.initialized = true;
+            }
+        };
+        ModuleWithLogic = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [])
+        ], ModuleWithLogic);
+        container.addModule(ModuleWithLogic, { providers: [] });
+        const instance = await instantiateModule(ModuleWithLogic);
+        expect(instance.initialized).toBe(true);
+    });
+    it("should pass resolved dependencies to constructor", async () => {
+        let Config = class Config {
+            setting = "configured";
+        };
+        Config = __decorate([
+            Injectable()
+        ], Config);
+        let AppModule = class AppModule {
+            configValue;
+            constructor(config) {
+                this.configValue = config.setting;
+            }
+        };
+        AppModule = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [Config])
+        ], AppModule);
+        Reflect.defineMetadata("design:paramtypes", [Config], AppModule);
+        container.addModule(AppModule, { providers: [] });
+        container.addProvider(AppModule, Config);
+        const instance = await instantiateModule(AppModule);
+        expect(instance.configValue).toBe("configured");
+    });
+    it("should return the created instance", async () => {
+        let ReturnTestModule = class ReturnTestModule {
+        };
+        ReturnTestModule = __decorate([
+            Injectable()
+        ], ReturnTestModule);
+        container.addModule(ReturnTestModule, { providers: [] });
+        const result = await instantiateModule(ReturnTestModule);
+        expect(result).toBeDefined();
+        expect(result).toBeInstanceOf(ReturnTestModule);
+    });
+    it("should handle async dependency resolution", async () => {
+        let AsyncDep = class AsyncDep {
+            value = "async";
+        };
+        AsyncDep = __decorate([
+            Injectable()
+        ], AsyncDep);
+        let AsyncModule = class AsyncModule {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+        };
+        AsyncModule = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [AsyncDep])
+        ], AsyncModule);
+        Reflect.defineMetadata("design:paramtypes", [AsyncDep], AsyncModule);
+        container.addModule(AsyncModule, { providers: [] });
+        container.addProvider(AsyncModule, AsyncDep);
+        const instance = await instantiateModule(AsyncModule);
+        expect(instance).toBeInstanceOf(AsyncModule);
+        expect(instance.dep.value).toBe("async");
+    });
+});

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

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

package/dist/@core/bootstrap/__tests__/register-imports.test.js

@@ -0,0 +1,112 @@
+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;
+};
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { registerImports } from "../register-imports.js";
+import { RgModule } from "../../decorators/rg-module.js";
+import { container } from "../../container.js";
+import "reflect-metadata/lite";
+describe("registerImports", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should return early if no imports in metadata", async () => {
+        const metadata = {};
+        await expect(registerImports(metadata)).resolves.toBeUndefined();
+    });
+    it("should initialize imported module", async () => {
+        let ImportedModule = class ImportedModule {
+        };
+        ImportedModule = __decorate([
+            RgModule({
+                providers: [],
+            })
+        ], ImportedModule);
+        const metadata = {
+            imports: [ImportedModule],
+        };
+        await registerImports(metadata);
+        expect(container.hasModule(ImportedModule)).toBe(true);
+    });
+    it("should initialize multiple imported modules", async () => {
+        let Module1 = class Module1 {
+        };
+        Module1 = __decorate([
+            RgModule({
+                providers: [],
+            })
+        ], Module1);
+        let Module2 = class Module2 {
+        };
+        Module2 = __decorate([
+            RgModule({
+                providers: [],
+            })
+        ], Module2);
+        const metadata = {
+            imports: [Module1, Module2],
+        };
+        await registerImports(metadata);
+        expect(container.hasModule(Module1)).toBe(true);
+        expect(container.hasModule(Module2)).toBe(true);
+    });
+    it("should handle empty imports array", async () => {
+        const metadata = {
+            imports: [],
+        };
+        await expect(registerImports(metadata)).resolves.toBeUndefined();
+    });
+    it("should skip module without @RgModule decorator", async () => {
+        class NonDecoratedModule {
+        }
+        const metadata = {
+            imports: [NonDecoratedModule],
+        };
+        // Should not throw, just skip initialization
+        await expect(registerImports(metadata)).resolves.toBeUndefined();
+    });
+    it("should initialize nested imports", async () => {
+        let NestedModule = class NestedModule {
+        };
+        NestedModule = __decorate([
+            RgModule({
+                providers: [],
+            })
+        ], NestedModule);
+        let ParentModule = class ParentModule {
+        };
+        ParentModule = __decorate([
+            RgModule({
+                imports: [NestedModule],
+                providers: [],
+            })
+        ], ParentModule);
+        const metadata = {
+            imports: [ParentModule],
+        };
+        await registerImports(metadata);
+        expect(container.hasModule(ParentModule)).toBe(true);
+        expect(container.hasModule(NestedModule)).toBe(true);
+    });
+    it("should handle module with providers", async () => {
+        class Service {
+        }
+        let ModuleWithProviders = class ModuleWithProviders {
+        };
+        ModuleWithProviders = __decorate([
+            RgModule({
+                providers: [Service],
+            })
+        ], ModuleWithProviders);
+        const metadata = {
+            imports: [ModuleWithProviders],
+        };
+        await registerImports(metadata);
+        expect(container.hasModule(ModuleWithProviders)).toBe(true);
+        const provider = container.getProvider(ModuleWithProviders, Service);
+        expect(provider).toBe(Service);
+    });
+});

package/dist/@core/bootstrap/__tests__/register-ipc-handlers.test.d.ts

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

package/dist/@core/bootstrap/__tests__/register-ipc-handlers.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { registerIpcHandlers } from "../register-ipc-handlers.js";
+import { container } from "../../container.js";
+import "reflect-metadata/lite";
+describe("registerIpcHandlers", () => {
+    let TestModule;
+    beforeEach(() => {
+        TestModule = class TestModule {
+        };
+        container.addModule(TestModule, { providers: [] });
+    });
+    it("should return early if no ipc in metadata", async () => {
+        const metadata = {};
+        await expect(registerIpcHandlers(TestModule, metadata)).resolves.toBeUndefined();
+    });
+    it("should register IPC handler class", async () => {
+        class TestHandler {
+            onInit(data) { }
+        }
+        const metadata = {
+            ipc: [TestHandler],
+        };
+        await registerIpcHandlers(TestModule, metadata);
+        const provider = container.getProvider(TestModule, TestHandler);
+        expect(provider).toBe(TestHandler);
+    });
+    it("should register multiple IPC handlers", async () => {
+        class Handler1 {
+            onInit(data) { }
+        }
+        class Handler2 {
+            onInit(data) { }
+        }
+        class Handler3 {
+            onInit(data) { }
+        }
+        const metadata = {
+            ipc: [Handler1, Handler2, Handler3],
+        };
+        await registerIpcHandlers(TestModule, metadata);
+        expect(container.getProvider(TestModule, Handler1)).toBe(Handler1);
+        expect(container.getProvider(TestModule, Handler2)).toBe(Handler2);
+        expect(container.getProvider(TestModule, Handler3)).toBe(Handler3);
+    });
+    it("should handle empty ipc array", async () => {
+        const metadata = {
+            ipc: [],
+        };
+        await expect(registerIpcHandlers(TestModule, metadata)).resolves.toBeUndefined();
+    });
+    it("should register handlers with constructor parameters", async () => {
+        class Dependency {
+        }
+        class HandlerWithDeps {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+            onInit(data) { }
+        }
+        const metadata = {
+            ipc: [HandlerWithDeps],
+        };
+        await registerIpcHandlers(TestModule, metadata);
+        const provider = container.getProvider(TestModule, HandlerWithDeps);
+        expect(provider).toBe(HandlerWithDeps);
+    });
+});

package/dist/@core/bootstrap/__tests__/register-providers.test.d.ts

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

package/dist/@core/bootstrap/__tests__/register-providers.test.js

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { registerProviders } from "../register-providers.js";
+import { InvalidProviderError } from "../../errors/index.js";
+import { container } from "../../container.js";
+import "reflect-metadata/lite";
+describe("registerProviders", () => {
+    let TestModule;
+    beforeEach(() => {
+        TestModule = class TestModule {
+        };
+        container.addModule(TestModule, { providers: [] });
+    });
+    it("should return early if no providers in metadata", async () => {
+        const metadata = {};
+        await expect(registerProviders(TestModule, metadata)).resolves.toBeUndefined();
+    });
+    it("should register class constructor providers", async () => {
+        class ServiceA {
+        }
+        class ServiceB {
+        }
+        const metadata = {
+            providers: [ServiceA, ServiceB],
+        };
+        await registerProviders(TestModule, metadata);
+        const providerA = container.getProvider(TestModule, ServiceA);
+        const providerB = container.getProvider(TestModule, ServiceB);
+        expect(providerA).toBe(ServiceA);
+        expect(providerB).toBe(ServiceB);
+    });
+    it("should register value providers", async () => {
+        const valueProvider = {
+            provide: "CONFIG",
+            useValue: { key: "value" },
+        };
+        const metadata = {
+            providers: [valueProvider],
+        };
+        await registerProviders(TestModule, metadata);
+        const provider = container.getProvider(TestModule, "CONFIG");
+        expect(provider).toBe(valueProvider);
+    });
+    it("should register factory providers", async () => {
+        const factoryProvider = {
+            provide: "FACTORY",
+            useFactory: () => ({ created: true }),
+        };
+        const metadata = {
+            providers: [factoryProvider],
+        };
+        await registerProviders(TestModule, metadata);
+        const provider = container.getProvider(TestModule, "FACTORY");
+        expect(provider).toBe(factoryProvider);
+    });
+    it("should register class providers", async () => {
+        class Implementation {
+        }
+        const classProvider = {
+            provide: "INTERFACE",
+            useClass: Implementation,
+        };
+        const metadata = {
+            providers: [classProvider],
+        };
+        await registerProviders(TestModule, metadata);
+        const provider = container.getProvider(TestModule, "INTERFACE");
+        expect(provider).toBe(classProvider);
+    });
+    it("should register existing providers", async () => {
+        const existingProvider = {
+            provide: "ALIAS",
+            useExisting: "ORIGINAL",
+        };
+        const metadata = {
+            providers: [existingProvider],
+        };
+        await registerProviders(TestModule, metadata);
+        const provider = container.getProvider(TestModule, "ALIAS");
+        expect(provider).toBe(existingProvider);
+    });
+    it("should register mixed provider types", async () => {
+        class ServiceClass {
+        }
+        const valueProvider = {
+            provide: "VALUE",
+            useValue: "test",
+        };
+        const metadata = {
+            providers: [ServiceClass, valueProvider],
+        };
+        await registerProviders(TestModule, metadata);
+        expect(container.getProvider(TestModule, ServiceClass)).toBe(ServiceClass);
+        expect(container.getProvider(TestModule, "VALUE")).toBe(valueProvider);
+    });
+    it("should throw InvalidProviderError for invalid provider", async () => {
+        const metadata = {
+            providers: ["invalid"],
+        };
+        await expect(registerProviders(TestModule, metadata)).rejects.toThrow(InvalidProviderError);
+    });
+    it("should throw InvalidProviderError for null provider", async () => {
+        const metadata = {
+            providers: [null],
+        };
+        await expect(registerProviders(TestModule, metadata)).rejects.toThrow(InvalidProviderError);
+    });
+    it("should throw InvalidProviderError for object without provide property", async () => {
+        const metadata = {
+            providers: [{ someKey: "value" }],
+        };
+        await expect(registerProviders(TestModule, metadata)).rejects.toThrow(InvalidProviderError);
+    });
+    it("should handle empty providers array", async () => {
+        const metadata = {
+            providers: [],
+        };
+        await expect(registerProviders(TestModule, metadata)).resolves.toBeUndefined();
+    });
+    it("should register symbol tokens", async () => {
+        const TOKEN = Symbol("test");
+        const provider = {
+            provide: TOKEN,
+            useValue: "test-value",
+        };
+        const metadata = {
+            providers: [provider],
+        };
+        await registerProviders(TestModule, metadata);
+        const registered = container.getProvider(TestModule, TOKEN);
+        expect(registered).toBe(provider);
+    });
+});

package/dist/@core/bootstrap/__tests__/register-windows.test.d.ts

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

package/dist/@core/bootstrap/__tests__/register-windows.test.js

@@ -0,0 +1,109 @@
+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;
+};
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { registerWindows } from "../register-windows.js";
+import { container } from "../../container.js";
+import { WindowManager } from "../../decorators/window-manager.js";
+import "reflect-metadata/lite";
+describe("registerWindows", () => {
+    let TestModule;
+    beforeEach(() => {
+        TestModule = class TestModule {
+        };
+        container.addModule(TestModule, { providers: [] });
+        vi.clearAllMocks();
+    });
+    it("should return early if no windows in metadata", async () => {
+        const metadata = {};
+        await expect(registerWindows(TestModule, metadata)).resolves.toBeUndefined();
+    });
+    it("should register window with hash", async () => {
+        let MainWindow = class MainWindow {
+        };
+        MainWindow = __decorate([
+            WindowManager({
+                hash: "main-window",
+                options: { width: 800, height: 600 },
+            })
+        ], MainWindow);
+        const metadata = {
+            windows: [MainWindow],
+        };
+        await registerWindows(TestModule, metadata);
+        const provider = container.getProvider(TestModule, "main-window");
+        expect(provider).toBeDefined();
+        expect(provider).toHaveProperty("metadata");
+        expect(provider).toHaveProperty("windowClass");
+    });
+    it("should register multiple windows", async () => {
+        let MainWindow = class MainWindow {
+        };
+        MainWindow = __decorate([
+            WindowManager({
+                hash: "main-window",
+                options: { width: 800 },
+            })
+        ], MainWindow);
+        let SettingsWindow = class SettingsWindow {
+        };
+        SettingsWindow = __decorate([
+            WindowManager({
+                hash: "settings-window",
+                options: { width: 600 },
+            })
+        ], SettingsWindow);
+        const metadata = {
+            windows: [MainWindow, SettingsWindow],
+        };
+        await registerWindows(TestModule, metadata);
+        const mainProvider = container.getProvider(TestModule, "main-window");
+        const settingsProvider = container.getProvider(TestModule, "settings-window");
+        expect(mainProvider).toBeDefined();
+        expect(settingsProvider).toBeDefined();
+    });
+    it("should not register window without hash", async () => {
+        let NoHashWindow = class NoHashWindow {
+        };
+        NoHashWindow = __decorate([
+            WindowManager({
+                options: { width: 800 },
+            })
+        ], NoHashWindow);
+        const metadata = {
+            windows: [NoHashWindow],
+        };
+        await registerWindows(TestModule, metadata);
+        // Since hash is undefined, it shouldn't register
+        const provider = container.getProvider(TestModule, undefined);
+        expect(provider).toBeUndefined();
+    });
+    it("should handle empty windows array", async () => {
+        const metadata = {
+            windows: [],
+        };
+        await expect(registerWindows(TestModule, metadata)).resolves.toBeUndefined();
+    });
+    it("should store window metadata and class", async () => {
+        const windowOptions = {
+            name: "test",
+            hash: "test-window",
+            options: { width: 1024, height: 768 },
+        };
+        let TestWindow = class TestWindow {
+        };
+        TestWindow = __decorate([
+            WindowManager(windowOptions)
+        ], TestWindow);
+        const metadata = {
+            windows: [TestWindow],
+        };
+        await registerWindows(TestModule, metadata);
+        const provider = container.getProvider(TestModule, "test-window");
+        expect(provider.windowClass).toBe(TestWindow);
+        expect(provider.metadata).toEqual(windowOptions);
+    });
+});

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

@@ -0,0 +1 @@
+export {};