@devisfuture/electron-modular 1.1.10 → 1.1.11

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

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

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

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

@@ -1,141 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { initSettings, getSettings } from "../settings.js";
-import { SettingsNotInitializedError } from "../../errors/index.js";
-describe("settings", () => {
-    beforeEach(() => {
-        // Clear settings before each test
-        // Since we can't directly clear the Map, we'll re-initialize
-    });
-    describe("initSettings", () => {
-        it("should initialize settings", () => {
-            const settings = {
-                localhostPort: "3000",
-                folders: {
-                    distRenderer: "dist-renderer",
-                    distMain: "dist-main",
-                },
-            };
-            initSettings(settings);
-            const retrieved = getSettings();
-            expect(retrieved).toEqual(settings);
-        });
-        it("should initialize with CSP sources", () => {
-            const settings = {
-                localhostPort: "3000",
-                folders: {
-                    distRenderer: "dist-renderer",
-                    distMain: "dist-main",
-                },
-                cspConnectSources: ["https://api.example.com"],
-            };
-            initSettings(settings);
-            const retrieved = getSettings();
-            expect(retrieved.cspConnectSources).toEqual(["https://api.example.com"]);
-        });
-        it("should overwrite existing settings", () => {
-            const settings1 = {
-                localhostPort: "3000",
-                folders: {
-                    distRenderer: "dist",
-                    distMain: "main",
-                },
-            };
-            const settings2 = {
-                localhostPort: "4000",
-                folders: {
-                    distRenderer: "renderer",
-                    distMain: "backend",
-                },
-            };
-            initSettings(settings1);
-            initSettings(settings2);
-            const retrieved = getSettings();
-            expect(retrieved).toEqual(settings2);
-            expect(retrieved.localhostPort).toBe("4000");
-        });
-    });
-    describe("getSettings", () => {
-        it("should throw error if settings not initialized", () => {
-            // Create a new scenario where settings might not be initialized
-            // Since we can't clear the Map directly, this test demonstrates the error
-            expect(() => {
-                // This would throw if settings were not previously initialized
-                // For the actual test, we rely on beforeEach isolation
-            }).not.toThrow();
-        });
-        it("should return initialized settings", () => {
-            const settings = {
-                localhostPort: "5000",
-                folders: {
-                    distRenderer: "public",
-                    distMain: "server",
-                },
-            };
-            initSettings(settings);
-            const retrieved = getSettings();
-            expect(retrieved).toEqual(settings);
-            expect(retrieved.localhostPort).toBe("5000");
-        });
-        it("should return same reference on multiple calls", () => {
-            const settings = {
-                localhostPort: "3000",
-                folders: {
-                    distRenderer: "dist-renderer",
-                    distMain: "dist-main",
-                },
-            };
-            initSettings(settings);
-            const retrieved1 = getSettings();
-            const retrieved2 = getSettings();
-            expect(retrieved1).toBe(retrieved2);
-        });
-        it("should preserve all settings properties", () => {
-            const settings = {
-                localhostPort: "8080",
-                folders: {
-                    distRenderer: "build/renderer",
-                    distMain: "build/main",
-                },
-                cspConnectSources: [
-                    "https://api1.example.com",
-                    "https://api2.example.com",
-                ],
-            };
-            initSettings(settings);
-            const retrieved = getSettings();
-            expect(retrieved.localhostPort).toBe("8080");
-            expect(retrieved.folders.distRenderer).toBe("build/renderer");
-            expect(retrieved.folders.distMain).toBe("build/main");
-            expect(retrieved.cspConnectSources).toHaveLength(2);
-        });
-    });
-    describe("type safety", () => {
-        it("should require all mandatory fields", () => {
-            const settings = {
-                localhostPort: "3000",
-                folders: {
-                    distRenderer: "dist-renderer",
-                    distMain: "dist-main",
-                },
-            };
-            initSettings(settings);
-            const retrieved = getSettings();
-            expect(retrieved.localhostPort).toBeDefined();
-            expect(retrieved.folders).toBeDefined();
-            expect(retrieved.folders.distRenderer).toBeDefined();
-            expect(retrieved.folders.distMain).toBeDefined();
-        });
-        it("should handle optional CSP sources", () => {
-            const settingsWithoutCSP = {
-                localhostPort: "3000",
-                folders: {
-                    distRenderer: "dist-renderer",
-                    distMain: "dist-main",
-                },
-            };
-            initSettings(settingsWithoutCSP);
-            const retrieved = getSettings();
-            expect(retrieved.cspConnectSources).toBeUndefined();
-        });
-    });
-});

package/dist/@core/control-window/__tests__/cache.test.d.ts

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

package/dist/@core/control-window/__tests__/cache.test.js

@@ -1,50 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { cacheWindows } from "../cache.js";
-describe("cacheWindows", () => {
-    beforeEach(() => {
-        cacheWindows.clear();
-    });
-    it("should be a Map instance", () => {
-        expect(cacheWindows).toBeInstanceOf(Map);
-    });
-    it("should store window references", () => {
-        const mockWindow = { id: 1 };
-        cacheWindows.set("main", mockWindow);
-        expect(cacheWindows.get("main")).toBe(mockWindow);
-    });
-    it("should allow multiple windows", () => {
-        const window1 = { id: 1 };
-        const window2 = { id: 2 };
-        cacheWindows.set("main", window1);
-        cacheWindows.set("settings", window2);
-        expect(cacheWindows.get("main")).toBe(window1);
-        expect(cacheWindows.get("settings")).toBe(window2);
-        expect(cacheWindows.size).toBe(2);
-    });
-    it("should overwrite existing entries", () => {
-        const window1 = { id: 1 };
-        const window2 = { id: 2 };
-        cacheWindows.set("main", window1);
-        cacheWindows.set("main", window2);
-        expect(cacheWindows.get("main")).toBe(window2);
-        expect(cacheWindows.size).toBe(1);
-    });
-    it("should delete entries", () => {
-        const mockWindow = { id: 1 };
-        cacheWindows.set("main", mockWindow);
-        cacheWindows.delete("main");
-        expect(cacheWindows.get("main")).toBeUndefined();
-    });
-    it("should clear all entries", () => {
-        cacheWindows.set("main", { id: 1 });
-        cacheWindows.set("settings", { id: 2 });
-        cacheWindows.clear();
-        expect(cacheWindows.size).toBe(0);
-    });
-    it("should check if key exists", () => {
-        const mockWindow = { id: 1 };
-        cacheWindows.set("main", mockWindow);
-        expect(cacheWindows.has("main")).toBe(true);
-        expect(cacheWindows.has("settings")).toBe(false);
-    });
-});

package/dist/@core/control-window/__tests__/destroy.test.d.ts

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

package/dist/@core/control-window/__tests__/destroy.test.js

@@ -1,69 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { BrowserWindow } from "electron";
-import { destroyWindows } from "../destroy.js";
-describe("destroyWindows", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should destroy all windows", () => {
-        const mockWindow1 = {
-            isDestroyed: vi.fn(() => false),
-            destroy: vi.fn(),
-        };
-        const mockWindow2 = {
-            isDestroyed: vi.fn(() => false),
-            destroy: vi.fn(),
-        };
-        vi.spyOn(BrowserWindow, "getAllWindows").mockReturnValue([
-            mockWindow1,
-            mockWindow2,
-        ]);
-        destroyWindows();
-        expect(mockWindow1.destroy).toHaveBeenCalledOnce();
-        expect(mockWindow2.destroy).toHaveBeenCalledOnce();
-    });
-    it("should not destroy already destroyed windows", () => {
-        const mockWindow1 = {
-            isDestroyed: vi.fn(() => true),
-            destroy: vi.fn(),
-        };
-        const mockWindow2 = {
-            isDestroyed: vi.fn(() => false),
-            destroy: vi.fn(),
-        };
-        vi.spyOn(BrowserWindow, "getAllWindows").mockReturnValue([
-            mockWindow1,
-            mockWindow2,
-        ]);
-        destroyWindows();
-        expect(mockWindow1.destroy).not.toHaveBeenCalled();
-        expect(mockWindow2.destroy).toHaveBeenCalledOnce();
-    });
-    it("should handle empty window list", () => {
-        vi.spyOn(BrowserWindow, "getAllWindows").mockReturnValue([]);
-        expect(() => destroyWindows()).not.toThrow();
-    });
-    it("should handle single window", () => {
-        const mockWindow = {
-            isDestroyed: vi.fn(() => false),
-            destroy: vi.fn(),
-        };
-        vi.spyOn(BrowserWindow, "getAllWindows").mockReturnValue([
-            mockWindow,
-        ]);
-        destroyWindows();
-        expect(mockWindow.destroy).toHaveBeenCalledOnce();
-    });
-    it("should check isDestroyed before destroying", () => {
-        const mockWindow = {
-            isDestroyed: vi.fn(() => false),
-            destroy: vi.fn(),
-        };
-        vi.spyOn(BrowserWindow, "getAllWindows").mockReturnValue([
-            mockWindow,
-        ]);
-        destroyWindows();
-        expect(mockWindow.isDestroyed).toHaveBeenCalled();
-        expect(mockWindow.destroy).toHaveBeenCalled();
-    });
-});

package/dist/@core/control-window/__tests__/receive.test.d.ts

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

package/dist/@core/control-window/__tests__/receive.test.js

@@ -1,68 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { getWindow } from "../receive.js";
-import { cacheWindows } from "../cache.js";
-describe("getWindow", () => {
-    beforeEach(() => {
-        cacheWindows.clear();
-    });
-    it("should return undefined if window not found", () => {
-        const result = getWindow("nonexistent");
-        expect(result).toBeUndefined();
-    });
-    it("should return cached window", () => {
-        const mockWindow = {
-            id: 1,
-            isDestroyed: () => false,
-        };
-        cacheWindows.set("main", mockWindow);
-        const result = getWindow("main");
-        expect(result).toBe(mockWindow);
-    });
-    it("should return undefined if window is destroyed", () => {
-        const mockWindow = {
-            id: 1,
-            isDestroyed: () => true,
-        };
-        cacheWindows.set("main", mockWindow);
-        const result = getWindow("main");
-        expect(result).toBeUndefined();
-    });
-    it("should return undefined if cached value is boolean", () => {
-        cacheWindows.set("main", true);
-        const result = getWindow("main");
-        expect(result).toBeUndefined();
-    });
-    it("should handle different window names", () => {
-        const mainWindow = {
-            id: 1,
-            isDestroyed: () => false,
-        };
-        const settingsWindow = {
-            id: 2,
-            isDestroyed: () => false,
-        };
-        cacheWindows.set("main", mainWindow);
-        cacheWindows.set("settings", settingsWindow);
-        expect(getWindow("main")).toBe(mainWindow);
-        expect(getWindow("settings")).toBe(settingsWindow);
-    });
-    it("should handle string window names", () => {
-        const mockWindow = {
-            id: 1,
-            isDestroyed: () => false,
-        };
-        cacheWindows.set("custom-window-name", mockWindow);
-        const result = getWindow("custom-window-name");
-        expect(result).toBe(mockWindow);
-    });
-    it("should return undefined after window is removed from cache", () => {
-        const mockWindow = {
-            id: 1,
-            isDestroyed: () => false,
-        };
-        cacheWindows.set("main", mockWindow);
-        cacheWindows.delete("main");
-        const result = getWindow("main");
-        expect(result).toBeUndefined();
-    });
-});

package/dist/@core/decorators/__tests__/inject.test.d.ts

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

package/dist/@core/decorators/__tests__/inject.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);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { describe, it, expect } from "vitest";
-import { Inject, getInjectedTokens } from "../inject.js";
-import "reflect-metadata/lite";
-describe("Inject decorator", () => {
-    describe("@Inject", () => {
-        it("should store injection token for parameter", () => {
-            const TOKEN = Symbol("test-token");
-            let TestService = class TestService {
-                dependency;
-                constructor(dependency) {
-                    this.dependency = dependency;
-                }
-            };
-            TestService = __decorate([
-                __param(0, Inject(TOKEN)),
-                __metadata("design:paramtypes", [Object])
-            ], TestService);
-            const tokens = getInjectedTokens(TestService);
-            expect(tokens[0]).toBe(TOKEN);
-        });
-        it("should handle multiple injection tokens", () => {
-            const TOKEN1 = Symbol("token-1");
-            const TOKEN2 = Symbol("token-2");
-            const TOKEN3 = Symbol("token-3");
-            let TestService = class TestService {
-                dep1;
-                dep2;
-                dep3;
-                constructor(dep1, dep2, dep3) {
-                    this.dep1 = dep1;
-                    this.dep2 = dep2;
-                    this.dep3 = dep3;
-                }
-            };
-            TestService = __decorate([
-                __param(0, Inject(TOKEN1)),
-                __param(1, Inject(TOKEN2)),
-                __param(2, Inject(TOKEN3)),
-                __metadata("design:paramtypes", [Object, Object, Object])
-            ], TestService);
-            const tokens = getInjectedTokens(TestService);
-            expect(tokens[0]).toBe(TOKEN1);
-            expect(tokens[1]).toBe(TOKEN2);
-            expect(tokens[2]).toBe(TOKEN3);
-        });
-        it("should handle string tokens", () => {
-            const TOKEN = "StringToken";
-            let TestService = class TestService {
-                dependency;
-                constructor(dependency) {
-                    this.dependency = dependency;
-                }
-            };
-            TestService = __decorate([
-                __param(0, Inject(TOKEN)),
-                __metadata("design:paramtypes", [Object])
-            ], TestService);
-            const tokens = getInjectedTokens(TestService);
-            expect(tokens[0]).toBe(TOKEN);
-        });
-        it("should handle class constructor tokens", () => {
-            class DependencyClass {
-            }
-            let TestService = class TestService {
-                dependency;
-                constructor(dependency) {
-                    this.dependency = dependency;
-                }
-            };
-            TestService = __decorate([
-                __param(0, Inject(DependencyClass)),
-                __metadata("design:paramtypes", [Object])
-            ], TestService);
-            const tokens = getInjectedTokens(TestService);
-            expect(tokens[0]).toBe(DependencyClass);
-        });
-        it("should ignore property decorators", () => {
-            const TOKEN = Symbol("test-token");
-            class TestService {
-                // @ts-expect-error - Testing that property decorators are ignored (Inject is a ParameterDecorator)
-                property;
-            }
-            __decorate([
-                Inject(TOKEN),
-                __metadata("design:type", Object)
-            ], TestService.prototype, "property", void 0);
-            const tokens = getInjectedTokens(TestService);
-            expect(Object.keys(tokens).length).toBe(0);
-        });
-        it("should handle mixed decorated and non-decorated parameters", () => {
-            const TOKEN = Symbol("token");
-            class Dependency {
-            }
-            let TestService = class TestService {
-                injected;
-                notInjected;
-                constructor(injected, notInjected) {
-                    this.injected = injected;
-                    this.notInjected = notInjected;
-                }
-            };
-            TestService = __decorate([
-                __param(0, Inject(TOKEN)),
-                __metadata("design:paramtypes", [Object, Dependency])
-            ], TestService);
-            const tokens = getInjectedTokens(TestService);
-            expect(tokens[0]).toBe(TOKEN);
-        });
-        it("should preserve parameter indexes correctly", () => {
-            const TOKEN1 = Symbol("token-1");
-            const TOKEN3 = Symbol("token-3");
-            class Dep2 {
-            }
-            let TestService = class TestService {
-                dep1;
-                dep2;
-                dep3;
-                constructor(dep1, dep2, dep3) {
-                    this.dep1 = dep1;
-                    this.dep2 = dep2;
-                    this.dep3 = dep3;
-                }
-            };
-            TestService = __decorate([
-                __param(0, Inject(TOKEN1)),
-                __param(2, Inject(TOKEN3)),
-                __metadata("design:paramtypes", [Object, Dep2, Object])
-            ], TestService);
-            const tokens = getInjectedTokens(TestService);
-            expect(tokens[0]).toBe(TOKEN1);
-            expect(tokens[2]).toBe(TOKEN3);
-        });
-    });
-    describe("getInjectedTokens", () => {
-        it("should return empty object for class without injections", () => {
-            class TestService {
-            }
-            const tokens = getInjectedTokens(TestService);
-            expect(tokens).toEqual({});
-        });
-        it("should return empty object for class with no constructor", () => {
-            class TestService {
-                method() { }
-            }
-            const tokens = getInjectedTokens(TestService);
-            expect(tokens).toEqual({});
-        });
-        it("should return metadata for decorated parameters", () => {
-            const TOKEN = Symbol("test");
-            let TestService = class TestService {
-                constructor(dep) { }
-            };
-            TestService = __decorate([
-                __param(0, Inject(TOKEN)),
-                __metadata("design:paramtypes", [Object])
-            ], TestService);
-            const tokens = getInjectedTokens(TestService);
-            expect(Object.keys(tokens).length).toBeGreaterThan(0);
-            expect(tokens[0]).toBe(TOKEN);
-        });
-    });
-});

package/dist/@core/decorators/__tests__/injectable.test.d.ts

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