@devisfuture/electron-modular 1.1.10 → 1.1.12

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

@@ -1,140 +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;
-};
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { initializeModule } from "../initialize-module.js";
-import { container } from "../../container.js";
-import { RgModule } from "../../decorators/rg-module.js";
-import { Injectable } from "../../decorators/injectable.js";
-import "reflect-metadata/lite";
-describe("initializeModule", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should add module to container", async () => {
-        let TestModule = class TestModule {
-        };
-        TestModule = __decorate([
-            RgModule({
-                providers: [],
-            })
-        ], TestModule);
-        const metadata = Reflect.getMetadata("RgModule", TestModule);
-        await initializeModule(TestModule, metadata);
-        expect(container.hasModule(TestModule)).toBe(true);
-    });
-    it("should set module metadata", async () => {
-        const metadata = {
-            providers: [],
-            exports: [],
-        };
-        let TestModule = class TestModule {
-        };
-        TestModule = __decorate([
-            RgModule(metadata)
-        ], TestModule);
-        await initializeModule(TestModule, metadata);
-        const storedMetadata = container.getModuleMetadata(TestModule);
-        expect(storedMetadata).toEqual(metadata);
-    });
-    it("should not re-initialize existing module", async () => {
-        let TestModule = class TestModule {
-        };
-        TestModule = __decorate([
-            RgModule({
-                providers: [],
-            })
-        ], TestModule);
-        const metadata = Reflect.getMetadata("RgModule", TestModule);
-        await initializeModule(TestModule, metadata);
-        await initializeModule(TestModule, metadata);
-        // Should only be added once
-        expect(container.hasModule(TestModule)).toBe(true);
-    });
-    it("should register providers", async () => {
-        let TestService = class TestService {
-        };
-        TestService = __decorate([
-            Injectable()
-        ], TestService);
-        let TestModule = class TestModule {
-        };
-        TestModule = __decorate([
-            RgModule({
-                providers: [TestService],
-            })
-        ], TestModule);
-        const metadata = Reflect.getMetadata("RgModule", TestModule);
-        await initializeModule(TestModule, metadata);
-        const provider = container.getProvider(TestModule, TestService);
-        expect(provider).toBe(TestService);
-    });
-    it("should register imports", async () => {
-        let ImportedModule = class ImportedModule {
-        };
-        ImportedModule = __decorate([
-            RgModule({
-                providers: [],
-            })
-        ], ImportedModule);
-        let TestModule = class TestModule {
-        };
-        TestModule = __decorate([
-            RgModule({
-                imports: [ImportedModule],
-                providers: [],
-            })
-        ], TestModule);
-        const metadata = Reflect.getMetadata("RgModule", TestModule);
-        await initializeModule(TestModule, metadata);
-        expect(container.hasModule(TestModule)).toBe(true);
-        expect(container.hasModule(ImportedModule)).toBe(true);
-    });
-    it("should handle module with all metadata properties", async () => {
-        let Service = class Service {
-        };
-        Service = __decorate([
-            Injectable()
-        ], Service);
-        class Handler {
-            onInit(data) { }
-        }
-        class Window {
-        }
-        let ImportedModule = class ImportedModule {
-        };
-        ImportedModule = __decorate([
-            RgModule({
-                providers: [],
-            })
-        ], ImportedModule);
-        let CompleteModule = class CompleteModule {
-        };
-        CompleteModule = __decorate([
-            RgModule({
-                imports: [ImportedModule],
-                providers: [Service],
-                ipc: [Handler],
-                windows: [Window],
-                exports: [Service],
-            })
-        ], CompleteModule);
-        const metadata = Reflect.getMetadata("RgModule", CompleteModule);
-        await initializeModule(CompleteModule, metadata);
-        expect(container.hasModule(CompleteModule)).toBe(true);
-        expect(container.getProvider(CompleteModule, Service)).toBe(Service);
-    });
-    it("should handle empty metadata", async () => {
-        let MinimalModule = class MinimalModule {
-        };
-        MinimalModule = __decorate([
-            RgModule({})
-        ], MinimalModule);
-        const metadata = Reflect.getMetadata("RgModule", MinimalModule);
-        await initializeModule(MinimalModule, metadata);
-        expect(container.hasModule(MinimalModule)).toBe(true);
-    });
-});

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

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

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

@@ -1,174 +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, 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

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

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

@@ -1,112 +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;
-};
-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

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

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

@@ -1,68 +0,0 @@
-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

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

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

@@ -1,132 +0,0 @@
-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

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