@devisfuture/electron-modular 1.1.9 → 1.1.10

package/dist/@core/decorators/__tests__/rg-module.test.js

@@ -0,0 +1,135 @@
+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 } from "vitest";
+import { RgModule } from "../rg-module.js";
+import "reflect-metadata/lite";
+describe("RgModule decorator", () => {
+    it("should store module metadata", () => {
+        const metadata = {
+            providers: [],
+            exports: [],
+        };
+        let TestModule = class TestModule {
+        };
+        TestModule = __decorate([
+            RgModule(metadata)
+        ], TestModule);
+        const storedMetadata = Reflect.getMetadata("RgModule", TestModule);
+        expect(storedMetadata).toEqual(metadata);
+    });
+    it("should store imports", () => {
+        class ImportedModule {
+        }
+        let TestModule = class TestModule {
+        };
+        TestModule = __decorate([
+            RgModule({
+                imports: [ImportedModule],
+            })
+        ], TestModule);
+        const metadata = Reflect.getMetadata("RgModule", TestModule);
+        expect(metadata.imports).toEqual([ImportedModule]);
+    });
+    it("should store providers", () => {
+        class ServiceA {
+        }
+        class ServiceB {
+        }
+        let TestModule = class TestModule {
+        };
+        TestModule = __decorate([
+            RgModule({
+                providers: [ServiceA, ServiceB],
+            })
+        ], TestModule);
+        const metadata = Reflect.getMetadata("RgModule", TestModule);
+        expect(metadata.providers).toEqual([ServiceA, ServiceB]);
+    });
+    it("should store exports", () => {
+        const TOKEN1 = Symbol("token1");
+        const TOKEN2 = "token2";
+        let TestModule = class TestModule {
+        };
+        TestModule = __decorate([
+            RgModule({
+                exports: [TOKEN1, TOKEN2],
+            })
+        ], TestModule);
+        const metadata = Reflect.getMetadata("RgModule", TestModule);
+        expect(metadata.exports).toEqual([TOKEN1, TOKEN2]);
+    });
+    it("should store IPC handlers", () => {
+        class Handler1 {
+            onInit(data) { }
+        }
+        class Handler2 {
+            onInit(data) { }
+        }
+        let TestModule = class TestModule {
+        };
+        TestModule = __decorate([
+            RgModule({
+                ipc: [Handler1, Handler2],
+            })
+        ], TestModule);
+        const metadata = Reflect.getMetadata("RgModule", TestModule);
+        expect(metadata.ipc).toEqual([Handler1, Handler2]);
+    });
+    it("should store windows", () => {
+        class Window1 {
+        }
+        class Window2 {
+        }
+        let TestModule = class TestModule {
+        };
+        TestModule = __decorate([
+            RgModule({
+                windows: [Window1, Window2],
+            })
+        ], TestModule);
+        const metadata = Reflect.getMetadata("RgModule", TestModule);
+        expect(metadata.windows).toEqual([Window1, Window2]);
+    });
+    it("should handle empty metadata", () => {
+        let TestModule = class TestModule {
+        };
+        TestModule = __decorate([
+            RgModule({})
+        ], TestModule);
+        const metadata = Reflect.getMetadata("RgModule", TestModule);
+        expect(metadata).toEqual({});
+    });
+    it("should work with complete metadata", () => {
+        class ImportModule {
+        }
+        class Provider1 {
+        }
+        class Handler1 {
+            onInit(data) { }
+        }
+        class Window1 {
+        }
+        const EXPORT_TOKEN = Symbol("export");
+        let CompleteModule = class CompleteModule {
+        };
+        CompleteModule = __decorate([
+            RgModule({
+                imports: [ImportModule],
+                providers: [Provider1],
+                ipc: [Handler1],
+                windows: [Window1],
+                exports: [EXPORT_TOKEN],
+            })
+        ], CompleteModule);
+        const metadata = Reflect.getMetadata("RgModule", CompleteModule);
+        expect(metadata.imports).toEqual([ImportModule]);
+        expect(metadata.providers).toEqual([Provider1]);
+        expect(metadata.ipc).toEqual([Handler1]);
+        expect(metadata.windows).toEqual([Window1]);
+        expect(metadata.exports).toEqual([EXPORT_TOKEN]);
+    });
+});

package/dist/@core/decorators/__tests__/window-manager.test.d.ts

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

package/dist/@core/decorators/__tests__/window-manager.test.js

@@ -0,0 +1,110 @@
+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 } from "vitest";
+import { WindowManager } from "../window-manager.js";
+import "reflect-metadata/lite";
+describe("WindowManager decorator", () => {
+    it("should store window creation options", () => {
+        const options = {
+            name: "main",
+            options: {
+                width: 800,
+                height: 600,
+            },
+        };
+        let MainWindow = class MainWindow {
+        };
+        MainWindow = __decorate([
+            WindowManager(options)
+        ], MainWindow);
+        const metadata = Reflect.getMetadata("WindowManager", MainWindow);
+        expect(metadata).toEqual(options);
+    });
+    it("should store window with custom name", () => {
+        const options = {
+            name: "settings",
+            options: {
+                width: 600,
+                height: 400,
+            },
+        };
+        let SettingsWindow = class SettingsWindow {
+        };
+        SettingsWindow = __decorate([
+            WindowManager(options)
+        ], SettingsWindow);
+        const metadata = Reflect.getMetadata("WindowManager", SettingsWindow);
+        expect(metadata.name).toBe("settings");
+    });
+    it("should store complete BrowserWindow options", () => {
+        const options = {
+            name: "main",
+            options: {
+                width: 1024,
+                height: 768,
+                webPreferences: {
+                    nodeIntegration: false,
+                    contextIsolation: true,
+                },
+                title: "Test Window",
+            },
+        };
+        let TestWindow = class TestWindow {
+        };
+        TestWindow = __decorate([
+            WindowManager(options)
+        ], TestWindow);
+        const metadata = Reflect.getMetadata("WindowManager", TestWindow);
+        expect(metadata.options.width).toBe(1024);
+        expect(metadata.options.height).toBe(768);
+        expect(metadata.options.webPreferences).toEqual({
+            nodeIntegration: false,
+            contextIsolation: true,
+        });
+    });
+    it("should work with minimal options", () => {
+        const options = {
+            name: "minimal",
+            options: {},
+        };
+        let MinimalWindow = class MinimalWindow {
+        };
+        MinimalWindow = __decorate([
+            WindowManager(options)
+        ], MinimalWindow);
+        const metadata = Reflect.getMetadata("WindowManager", MinimalWindow);
+        expect(metadata).toEqual(options);
+    });
+    it("should not affect non-decorated classes", () => {
+        class NonDecoratedWindow {
+        }
+        const metadata = Reflect.getMetadata("WindowManager", NonDecoratedWindow);
+        expect(metadata).toBeUndefined();
+    });
+    it("should work with multiple window managers", () => {
+        const mainOptions = {
+            name: "main",
+            options: { width: 800 },
+        };
+        const settingsOptions = {
+            name: "settings",
+            options: { width: 600 },
+        };
+        let MainWindow = class MainWindow {
+        };
+        MainWindow = __decorate([
+            WindowManager(mainOptions)
+        ], MainWindow);
+        let SettingsWindow = class SettingsWindow {
+        };
+        SettingsWindow = __decorate([
+            WindowManager(settingsOptions)
+        ], SettingsWindow);
+        expect(Reflect.getMetadata("WindowManager", MainWindow)).toEqual(mainOptions);
+        expect(Reflect.getMetadata("WindowManager", SettingsWindow)).toEqual(settingsOptions);
+    });
+});

package/dist/@core/errors/__tests__/index.test.d.ts

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

package/dist/@core/errors/__tests__/index.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect } from "vitest";
+import { ModuleNotRegisteredError, ProviderNotFoundError, ModuleDecoratorMissingError, InvalidProviderError, SettingsNotInitializedError, } from "../index.js";
+describe("Error classes", () => {
+    describe("ModuleNotRegisteredError", () => {
+        it("should create error with correct message", () => {
+            const error = new ModuleNotRegisteredError("TestModule");
+            expect(error.message).toBe('Module "TestModule" is not registered in the container.');
+            expect(error.name).toBe("ModuleNotRegisteredError");
+        });
+        it("should be instanceof Error", () => {
+            const error = new ModuleNotRegisteredError("TestModule");
+            expect(error).toBeInstanceOf(Error);
+        });
+        it("should be instanceof ModuleNotRegisteredError", () => {
+            const error = new ModuleNotRegisteredError("TestModule");
+            expect(error).toBeInstanceOf(ModuleNotRegisteredError);
+        });
+    });
+    describe("ProviderNotFoundError", () => {
+        it("should create error with correct message", () => {
+            const error = new ProviderNotFoundError("MyToken", "MyModule");
+            expect(error.message).toBe('Provider not found for token "MyToken" in module "MyModule" or its imports.');
+            expect(error.name).toBe("ProviderNotFoundError");
+        });
+        it("should be instanceof Error", () => {
+            const error = new ProviderNotFoundError("token", "module");
+            expect(error).toBeInstanceOf(Error);
+        });
+        it("should handle symbol tokens", () => {
+            const error = new ProviderNotFoundError("Symbol(test)", "TestModule");
+            expect(error.message).toContain("Symbol(test)");
+        });
+    });
+    describe("ModuleDecoratorMissingError", () => {
+        it("should create error with correct message", () => {
+            const error = new ModuleDecoratorMissingError("TestModule");
+            expect(error.message).toBe("Module TestModule does not have the @RgModule decorator");
+            expect(error.name).toBe("ModuleDecoratorMissingError");
+        });
+        it("should be instanceof Error", () => {
+            const error = new ModuleDecoratorMissingError("TestModule");
+            expect(error).toBeInstanceOf(Error);
+        });
+    });
+    describe("InvalidProviderError", () => {
+        it("should create error with correct message", () => {
+            const error = new InvalidProviderError("TestModule");
+            expect(error.message).toBe("Invalid provider definition registered in module TestModule");
+            expect(error.name).toBe("InvalidProviderError");
+        });
+        it("should be instanceof Error", () => {
+            const error = new InvalidProviderError("TestModule");
+            expect(error).toBeInstanceOf(Error);
+        });
+    });
+    describe("SettingsNotInitializedError", () => {
+        it("should create error with correct message", () => {
+            const error = new SettingsNotInitializedError();
+            expect(error.message).toBe("App settings cache has not been initialized.");
+            expect(error.name).toBe("SettingsNotInitializedError");
+        });
+        it("should be instanceof Error", () => {
+            const error = new SettingsNotInitializedError();
+            expect(error).toBeInstanceOf(Error);
+        });
+        it("should not require any parameters", () => {
+            expect(() => new SettingsNotInitializedError()).not.toThrow();
+        });
+    });
+    describe("Error throwing behavior", () => {
+        it("should be catchable", () => {
+            expect(() => {
+                throw new ModuleNotRegisteredError("Test");
+            }).toThrow(ModuleNotRegisteredError);
+        });
+        it("should preserve stack trace", () => {
+            const error = new ProviderNotFoundError("token", "module");
+            expect(error.stack).toBeDefined();
+            expect(error.stack).toContain("ProviderNotFoundError");
+        });
+    });
+});

package/dist/@core/utils/__tests__/dependency-tokens.test.d.ts

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

package/dist/@core/utils/__tests__/dependency-tokens.test.js

@@ -0,0 +1,186 @@
+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, vi } from "vitest";
+import { getDependencyTokens } from "../dependency-tokens.js";
+import { Inject } from "../../decorators/inject.js";
+import "reflect-metadata/lite";
+describe("getDependencyTokens", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should return empty array for class with no constructor parameters", () => {
+        class NoParams {
+        }
+        const tokens = getDependencyTokens(NoParams);
+        expect(tokens).toEqual([]);
+    });
+    it("should return design:paramtypes when available", () => {
+        class Dependency {
+        }
+        class ServiceWithDeps {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+        }
+        // Manually set metadata for testing since TypeScript compiler isn't running
+        Reflect.defineMetadata("design:paramtypes", [Dependency], ServiceWithDeps);
+        const tokens = getDependencyTokens(ServiceWithDeps);
+        expect(tokens).toHaveLength(1);
+        expect(tokens[0]).toBe(Dependency);
+    });
+    it("should return multiple parameter types", () => {
+        class Dep1 {
+        }
+        class Dep2 {
+        }
+        class Dep3 {
+        }
+        class ServiceWithMultipleDeps {
+            dep1;
+            dep2;
+            dep3;
+            constructor(dep1, dep2, dep3) {
+                this.dep1 = dep1;
+                this.dep2 = dep2;
+                this.dep3 = dep3;
+            }
+        }
+        Reflect.defineMetadata("design:paramtypes", [Dep1, Dep2, Dep3], ServiceWithMultipleDeps);
+        const tokens = getDependencyTokens(ServiceWithMultipleDeps);
+        expect(tokens).toHaveLength(3);
+        expect(tokens[0]).toBe(Dep1);
+        expect(tokens[1]).toBe(Dep2);
+        expect(tokens[2]).toBe(Dep3);
+    });
+    it("should override with @Inject decorator tokens", () => {
+        const CUSTOM_TOKEN = Symbol("custom");
+        class DefaultDep {
+        }
+        let ServiceWithInjectedToken = class ServiceWithInjectedToken {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+        };
+        ServiceWithInjectedToken = __decorate([
+            __param(0, Inject(CUSTOM_TOKEN)),
+            __metadata("design:paramtypes", [DefaultDep])
+        ], ServiceWithInjectedToken);
+        Reflect.defineMetadata("design:paramtypes", [DefaultDep], ServiceWithInjectedToken);
+        const tokens = getDependencyTokens(ServiceWithInjectedToken);
+        expect(tokens[0]).toBe(CUSTOM_TOKEN);
+    });
+    it("should handle mixed injected and non-injected parameters", () => {
+        const TOKEN1 = Symbol("token1");
+        const TOKEN3 = Symbol("token3");
+        class Dep2 {
+        }
+        let MixedService = class MixedService {
+            dep1;
+            dep2;
+            dep3;
+            constructor(dep1, dep2, dep3) {
+                this.dep1 = dep1;
+                this.dep2 = dep2;
+                this.dep3 = dep3;
+            }
+        };
+        MixedService = __decorate([
+            __param(0, Inject(TOKEN1)),
+            __param(2, Inject(TOKEN3)),
+            __metadata("design:paramtypes", [Object, Dep2, Object])
+        ], MixedService);
+        Reflect.defineMetadata("design:paramtypes", [Object, Dep2, Object], MixedService);
+        const tokens = getDependencyTokens(MixedService);
+        expect(tokens[0]).toBe(TOKEN1);
+        expect(tokens[1]).toBe(Dep2);
+        expect(tokens[2]).toBe(TOKEN3);
+    });
+    it("should handle string tokens from @Inject", () => {
+        const STRING_TOKEN = "MyStringToken";
+        let ServiceWithStringToken = class ServiceWithStringToken {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+        };
+        ServiceWithStringToken = __decorate([
+            __param(0, Inject(STRING_TOKEN)),
+            __metadata("design:paramtypes", [Object])
+        ], ServiceWithStringToken);
+        const tokens = getDependencyTokens(ServiceWithStringToken);
+        expect(tokens[0]).toBe(STRING_TOKEN);
+    });
+    it("should cache results for same constructor", () => {
+        class Dependency {
+        }
+        class CachedService {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+        }
+        Reflect.defineMetadata("design:paramtypes", [Dependency], CachedService);
+        const tokens1 = getDependencyTokens(CachedService);
+        const tokens2 = getDependencyTokens(CachedService);
+        expect(tokens1).toBe(tokens2);
+    });
+    it("should handle class with no design:paramtypes metadata", () => {
+        class NoMetadata {
+            constructor() { }
+        }
+        const tokens = getDependencyTokens(NoMetadata);
+        expect(tokens).toEqual([]);
+    });
+    it("should calculate maxIndex correctly when injected index exceeds paramTypes", () => {
+        const TOKEN = Symbol("token");
+        let EdgeCaseService = class EdgeCaseService {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+        };
+        EdgeCaseService = __decorate([
+            __param(0, Inject(TOKEN)),
+            __metadata("design:paramtypes", [Object])
+        ], EdgeCaseService);
+        const tokens = getDependencyTokens(EdgeCaseService);
+        expect(tokens.length).toBeGreaterThan(0);
+        expect(tokens[0]).toBe(TOKEN);
+    });
+    it("should handle multiple calls with different classes", () => {
+        class Dep1 {
+        }
+        class Dep2 {
+        }
+        class Service1 {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+        }
+        class Service2 {
+            dep;
+            constructor(dep) {
+                this.dep = dep;
+            }
+        }
+        Reflect.defineMetadata("design:paramtypes", [Dep1], Service1);
+        Reflect.defineMetadata("design:paramtypes", [Dep2], Service2);
+        const tokens1 = getDependencyTokens(Service1);
+        const tokens2 = getDependencyTokens(Service2);
+        expect(tokens1[0]).toBe(Dep1);
+        expect(tokens2[0]).toBe(Dep2);
+    });
+});

package/dist/__mocks__/electron.d.ts

@@ -0,0 +1,88 @@
+export declare const mockApp: {
+    getPath: import("vitest").Mock<(name: string) => string>;
+    getVersion: import("vitest").Mock<() => string>;
+    getName: import("vitest").Mock<() => string>;
+    quit: import("vitest").Mock<(...args: any[]) => any>;
+    exit: import("vitest").Mock<(...args: any[]) => any>;
+    on: import("vitest").Mock<(...args: any[]) => any>;
+    once: import("vitest").Mock<(...args: any[]) => any>;
+    removeListener: import("vitest").Mock<(...args: any[]) => any>;
+    whenReady: import("vitest").Mock<() => Promise<void>>;
+    isReady: import("vitest").Mock<() => boolean>;
+    getAppPath: import("vitest").Mock<() => string>;
+};
+export declare const mockBrowserWindow: import("vitest").Mock<(...args: any[]) => any>;
+export declare const mockIpcMain: {
+    on: import("vitest").Mock<(...args: any[]) => any>;
+    once: import("vitest").Mock<(...args: any[]) => any>;
+    handle: import("vitest").Mock<(...args: any[]) => any>;
+    removeHandler: import("vitest").Mock<(...args: any[]) => any>;
+    removeListener: import("vitest").Mock<(...args: any[]) => any>;
+    removeAllListeners: import("vitest").Mock<(...args: any[]) => any>;
+};
+export declare const mockDialog: {
+    showOpenDialog: import("vitest").Mock<() => Promise<{
+        canceled: boolean;
+        filePaths: string[];
+    }>>;
+    showSaveDialog: import("vitest").Mock<() => Promise<{
+        canceled: boolean;
+        filePath: string;
+    }>>;
+    showMessageBox: import("vitest").Mock<() => Promise<{
+        response: number;
+    }>>;
+    showErrorBox: import("vitest").Mock<(...args: any[]) => any>;
+};
+export declare const mockSession: {
+    defaultSession: {
+        webRequest: {
+            onHeadersReceived: import("vitest").Mock<(...args: any[]) => any>;
+        };
+    };
+};
+export declare const mockElectron: {
+    app: {
+        getPath: import("vitest").Mock<(name: string) => string>;
+        getVersion: import("vitest").Mock<() => string>;
+        getName: import("vitest").Mock<() => string>;
+        quit: import("vitest").Mock<(...args: any[]) => any>;
+        exit: import("vitest").Mock<(...args: any[]) => any>;
+        on: import("vitest").Mock<(...args: any[]) => any>;
+        once: import("vitest").Mock<(...args: any[]) => any>;
+        removeListener: import("vitest").Mock<(...args: any[]) => any>;
+        whenReady: import("vitest").Mock<() => Promise<void>>;
+        isReady: import("vitest").Mock<() => boolean>;
+        getAppPath: import("vitest").Mock<() => string>;
+    };
+    BrowserWindow: import("vitest").Mock<(...args: any[]) => any>;
+    ipcMain: {
+        on: import("vitest").Mock<(...args: any[]) => any>;
+        once: import("vitest").Mock<(...args: any[]) => any>;
+        handle: import("vitest").Mock<(...args: any[]) => any>;
+        removeHandler: import("vitest").Mock<(...args: any[]) => any>;
+        removeListener: import("vitest").Mock<(...args: any[]) => any>;
+        removeAllListeners: import("vitest").Mock<(...args: any[]) => any>;
+    };
+    dialog: {
+        showOpenDialog: import("vitest").Mock<() => Promise<{
+            canceled: boolean;
+            filePaths: string[];
+        }>>;
+        showSaveDialog: import("vitest").Mock<() => Promise<{
+            canceled: boolean;
+            filePath: string;
+        }>>;
+        showMessageBox: import("vitest").Mock<() => Promise<{
+            response: number;
+        }>>;
+        showErrorBox: import("vitest").Mock<(...args: any[]) => any>;
+    };
+    session: {
+        defaultSession: {
+            webRequest: {
+                onHeadersReceived: import("vitest").Mock<(...args: any[]) => any>;
+            };
+        };
+    };
+};

package/dist/__mocks__/electron.js

@@ -0,0 +1,76 @@
+import { vi } from "vitest";
+export const mockApp = {
+    getPath: vi.fn((name) => `/mock/path/${name}`),
+    getVersion: vi.fn(() => "1.0.0"),
+    getName: vi.fn(() => "MockApp"),
+    quit: vi.fn(),
+    exit: vi.fn(),
+    on: vi.fn(),
+    once: vi.fn(),
+    removeListener: vi.fn(),
+    whenReady: vi.fn(() => Promise.resolve()),
+    isReady: vi.fn(() => true),
+    getAppPath: vi.fn(() => "/mock/app"),
+};
+export const mockBrowserWindow = vi.fn().mockImplementation(() => ({
+    loadURL: vi.fn(() => Promise.resolve()),
+    loadFile: vi.fn(() => Promise.resolve()),
+    on: vi.fn(),
+    once: vi.fn(),
+    webContents: {
+        send: vi.fn(),
+        on: vi.fn(),
+        executeJavaScript: vi.fn(() => Promise.resolve()),
+        openDevTools: vi.fn(),
+        closeDevTools: vi.fn(),
+    },
+    show: vi.fn(),
+    hide: vi.fn(),
+    close: vi.fn(),
+    destroy: vi.fn(),
+    isDestroyed: vi.fn(() => false),
+    isFocused: vi.fn(() => true),
+    focus: vi.fn(),
+    id: 1,
+}));
+// Add static methods to mockBrowserWindow
+Object.assign(mockBrowserWindow, {
+    getAllWindows: vi.fn(() => []),
+});
+export const mockIpcMain = {
+    on: vi.fn(),
+    once: vi.fn(),
+    handle: vi.fn(),
+    removeHandler: vi.fn(),
+    removeListener: vi.fn(),
+    removeAllListeners: vi.fn(),
+};
+export const mockDialog = {
+    showOpenDialog: vi.fn(() => Promise.resolve({
+        canceled: false,
+        filePaths: ["/mock/file.txt"],
+    })),
+    showSaveDialog: vi.fn(() => Promise.resolve({
+        canceled: false,
+        filePath: "/mock/save.txt",
+    })),
+    showMessageBox: vi.fn(() => Promise.resolve({
+        response: 0,
+    })),
+    showErrorBox: vi.fn(),
+};
+export const mockSession = {
+    defaultSession: {
+        webRequest: {
+            onHeadersReceived: vi.fn(),
+        },
+    },
+};
+export const mockElectron = {
+    app: mockApp,
+    BrowserWindow: mockBrowserWindow,
+    ipcMain: mockIpcMain,
+    dialog: mockDialog,
+    session: mockSession,
+};
+vi.mock("electron", () => mockElectron);