@devisfuture/electron-modular 1.0.10

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

@@ -0,0 +1,2 @@
+import type { Constructor } from "../types/constructor.js";
+export declare const bootstrapModules: (modulesClass: Constructor[]) => Promise<void>;

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

@@ -0,0 +1,20 @@
+import { ModuleDecoratorMissingError } from "../errors/index.js";
+import { instantiateModule } from "./instantiate-module.js";
+import { initializeModule } from "./initialize-module.js";
+import { container } from "../container.js";
+import { initializeIpcHandlers } from "./initialize-ipc/handlers.js";
+export const bootstrapModules = async (modulesClass) => {
+    for (const moduleClass of modulesClass) {
+        const metadata = Reflect.getMetadata("RgModule", moduleClass);
+        if (!metadata) {
+            throw new ModuleDecoratorMissingError(moduleClass.name);
+        }
+        await initializeModule(moduleClass, metadata);
+        await instantiateModule(moduleClass);
+        await container.resolve(moduleClass, moduleClass);
+        if (metadata.windows?.length && !metadata.ipc?.length) {
+            console.warn(`Warning: Window(s) declared in module "${moduleClass.name}" but no IPC handlers found to manage them.`);
+        }
+        await initializeIpcHandlers(moduleClass, metadata);
+    }
+};

package/dist/@core/bootstrap/initialize-ipc/handlers.d.ts

@@ -0,0 +1,3 @@
+import type { Constructor } from "../../types/constructor.js";
+import type { RgModuleMetadata } from "../../types/module-metadata.js";
+export declare const initializeIpcHandlers: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;

package/dist/@core/bootstrap/initialize-ipc/handlers.js

@@ -0,0 +1,47 @@
+import { container } from "../../container.js";
+import { createWindowWithParams } from "./window-creator.js";
+import { createWindowInstance } from "./window-instance-creator.js";
+import { attachWindowEventListeners } from "./window-event-listeners.js";
+const createWindowFactory = (moduleClass, windowMetadata) => {
+    if (!windowMetadata?.metadata?.options ||
+        !windowMetadata.metadata.hash ||
+        !windowMetadata.windowClass) {
+        return {
+            create: async () => undefined,
+        };
+    }
+    return {
+        create: async (params) => {
+            const browserWindow = createWindowWithParams(windowMetadata.metadata, params);
+            const windowInstance = await createWindowInstance(moduleClass, windowMetadata.windowClass);
+            if (browserWindow && windowInstance) {
+                attachWindowEventListeners(browserWindow, windowInstance);
+                return browserWindow;
+            }
+            return undefined;
+        },
+    };
+};
+const createGetWindowFunction = (moduleClass) => {
+    return (name) => {
+        if (!name) {
+            return {
+                create: async () => undefined,
+            };
+        }
+        const windowMetadata = container.getProvider(moduleClass, name);
+        return createWindowFactory(moduleClass, windowMetadata);
+    };
+};
+export const initializeIpcHandlers = async (moduleClass, metadata) => {
+    if (!metadata.ipc) {
+        return;
+    }
+    const getWindow = createGetWindowFunction(moduleClass);
+    for (const ipcClass of metadata.ipc) {
+        const ipcInstance = await container.resolve(moduleClass, ipcClass);
+        if (ipcInstance?.onInit) {
+            ipcInstance.onInit({ getWindow });
+        }
+    }
+};

package/dist/@core/bootstrap/initialize-ipc/window-creator.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserWindow } from "electron";
+import type { TParamsCreateWindow } from "../../control-window/types.js";
+export declare const createWindowWithParams: <W extends TParamsCreateWindow>(baseMetadata: W, params?: W) => BrowserWindow;

package/dist/@core/bootstrap/initialize-ipc/window-creator.js

@@ -0,0 +1,28 @@
+import { createWindow } from "../../control-window/create.js";
+const isPlainObject = (value) => {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.prototype.toString.call(value) === "[object Object]");
+};
+const mergeDeep = (target, source) => {
+    const output = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+        if (isPlainObject(value)) {
+            const current = output[key];
+            output[key] = isPlainObject(current)
+                ? mergeDeep(current, value)
+                : mergeDeep({}, value);
+        }
+        else {
+            output[key] = value;
+        }
+    }
+    return output;
+};
+export const createWindowWithParams = (baseMetadata, params) => {
+    const mergedSettings = params !== undefined
+        ? mergeDeep(baseMetadata, params)
+        : baseMetadata;
+    return createWindow(mergedSettings);
+};

package/dist/@core/bootstrap/initialize-ipc/window-event-listeners.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserWindow } from "electron";
+import type { TWindowManagerWithHandlers } from "../../types/window-manager.js";
+export declare const attachWindowEventListeners: (win: BrowserWindow, inst: TWindowManagerWithHandlers) => void;

package/dist/@core/bootstrap/initialize-ipc/window-event-listeners.js

@@ -0,0 +1,61 @@
+const windowListeners = new WeakMap();
+const getPrototypeMethodNames = (instance) => {
+    const names = new Set();
+    let proto = Object.getPrototypeOf(instance);
+    while (proto && proto !== Object.prototype) {
+        Object.getOwnPropertyNames(proto).forEach((n) => n !== "constructor" && names.add(n));
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Array.from(names);
+};
+const toEventName = (h) => {
+    const c = h.replace(/^(onWindow|onWebContents|on)/, "");
+    return c
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2")
+        .toLowerCase();
+};
+const attachHandlersToEmitter = (emitter, win, inst, names, filter) => {
+    const cleanups = [];
+    for (const name of names) {
+        if (!filter(name))
+            continue;
+        const h = inst[name];
+        if (typeof h !== "function")
+            continue;
+        const evt = toEventName(name);
+        const listener = (...args) => {
+            h.length <= 1 ? h.apply(inst, [win]) : h.apply(inst, [...args, win]);
+        };
+        emitter.on(evt, listener);
+        cleanups.push(() => {
+            emitter.off
+                ? emitter.off(evt, listener)
+                : emitter.removeListener &&
+                    emitter.removeListener(evt, listener);
+        });
+    }
+    return cleanups;
+};
+export const attachWindowEventListeners = (win, inst) => {
+    const entry = windowListeners.get(win);
+    if (entry?.instance === inst)
+        return;
+    if (entry)
+        entry.cleanup.forEach((c) => c());
+    const names = getPrototypeMethodNames(inst).filter((n) => n.startsWith("on"));
+    const isWebContents = (n) => n.startsWith("onWebContents");
+    const winCleanups = attachHandlersToEmitter(win, win, inst, names, (n) => !isWebContents(n));
+    const webCleanups = attachHandlersToEmitter(win.webContents, win, inst, names, isWebContents);
+    windowListeners.set(win, {
+        instance: inst,
+        cleanup: [...winCleanups, ...webCleanups],
+    });
+    win.once("closed", () => {
+        const e = windowListeners.get(win);
+        if (e) {
+            e.cleanup.forEach((c) => c());
+            windowListeners.delete(win);
+        }
+    });
+};

package/dist/@core/bootstrap/initialize-ipc/window-instance-creator.d.ts

@@ -0,0 +1,3 @@
+import type { Constructor } from "../../types/constructor.js";
+import type { TWindowManagerWithHandlers } from "../../types/window-manager.js";
+export declare const createWindowInstance: <T extends TWindowManagerWithHandlers>(moduleClass: Constructor, windowClass: Constructor<T>) => Promise<T | undefined>;

package/dist/@core/bootstrap/initialize-ipc/window-instance-creator.js

@@ -0,0 +1,10 @@
+import { container } from "../../container.js";
+import { getDependencyTokens } from "../../utils/dependency-tokens.js";
+export const createWindowInstance = async (moduleClass, windowClass) => {
+    if (!windowClass) {
+        return undefined;
+    }
+    const dependenciesTypes = getDependencyTokens(windowClass);
+    const resolvedDependencies = await Promise.all(dependenciesTypes.map((depType) => container.resolve(moduleClass, depType)));
+    return new windowClass(...resolvedDependencies);
+};

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

@@ -0,0 +1,3 @@
+import type { RgModuleMetadata } from "../types/module-metadata.js";
+import type { Constructor } from "../types/constructor.js";
+export declare const initializeModule: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;

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

@@ -0,0 +1,18 @@
+import { container } from "../container.js";
+import { registerProviders } from "./register-providers.js";
+import { registerImports } from "./register-imports.js";
+import { registerWindows } from "./register-windows.js";
+import { registerIpcHandlers } from "./register-ipc-handlers.js";
+export const initializeModule = async (moduleClass, metadata) => {
+    const isNewModule = container.addModule(moduleClass, metadata);
+    container.setModuleMetadata(moduleClass, metadata);
+    if (!isNewModule) {
+        return;
+    }
+    await Promise.all([
+        registerProviders(moduleClass, metadata),
+        registerImports(metadata),
+        registerWindows(moduleClass, metadata),
+        registerIpcHandlers(moduleClass, metadata),
+    ]);
+};

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

@@ -0,0 +1,2 @@
+import type { Constructor } from "../types/constructor.js";
+export declare const instantiateModule: (moduleClass: Constructor) => Promise<unknown>;

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

@@ -0,0 +1,9 @@
+import { container } from "../container.js";
+import { getDependencyTokens } from "../utils/dependency-tokens.js";
+export const instantiateModule = async (moduleClass) => {
+    const dependencies = getDependencyTokens(moduleClass);
+    const resolvedDependencies = await Promise.all(dependencies.map((dependency) => container.resolve(moduleClass, dependency)));
+    const instance = new moduleClass(...resolvedDependencies);
+    container.registerInstance(moduleClass, instance);
+    return instance;
+};

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

@@ -0,0 +1,2 @@
+import type { RgModuleMetadata } from "../types/module-metadata.js";
+export declare const registerImports: (metadata: RgModuleMetadata) => Promise<void>;

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

@@ -0,0 +1,12 @@
+import { initializeModule } from "./initialize-module.js";
+export const registerImports = async (metadata) => {
+    if (!metadata.imports) {
+        return;
+    }
+    for (const importedModuleClass of metadata.imports) {
+        const importedModuleMetadata = Reflect.getMetadata("RgModule", importedModuleClass);
+        if (importedModuleMetadata) {
+            await initializeModule(importedModuleClass, importedModuleMetadata);
+        }
+    }
+};

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

@@ -0,0 +1,3 @@
+import type { Constructor } from "../types/constructor.js";
+import type { RgModuleMetadata } from "../types/module-metadata.js";
+export declare const registerIpcHandlers: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;

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

@@ -0,0 +1,9 @@
+import { container } from "../container.js";
+export const registerIpcHandlers = async (moduleClass, metadata) => {
+    if (!metadata.ipc) {
+        return;
+    }
+    for (const ipcClass of metadata.ipc) {
+        container.addProvider(moduleClass, ipcClass);
+    }
+};

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

@@ -0,0 +1,3 @@
+import type { Constructor } from "../types/constructor.js";
+import type { RgModuleMetadata } from "../types/module-metadata.js";
+export declare const registerProviders: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;

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

@@ -0,0 +1,21 @@
+import { InvalidProviderError } from "../errors/index.js";
+import { container } from "../container.js";
+const isProviderObject = (provider) => {
+    return (typeof provider === "object" && provider !== null && "provide" in provider);
+};
+export const registerProviders = async (moduleClass, metadata) => {
+    if (!metadata.providers) {
+        return;
+    }
+    for (const provider of metadata.providers) {
+        if (typeof provider === "function") {
+            container.addProvider(moduleClass, provider);
+            continue;
+        }
+        if (isProviderObject(provider)) {
+            container.addProvider(moduleClass, provider.provide, provider);
+            continue;
+        }
+        throw new InvalidProviderError(moduleClass.name);
+    }
+};

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

@@ -0,0 +1,3 @@
+import type { Constructor } from "../types/constructor.js";
+import type { RgModuleMetadata } from "../types/module-metadata.js";
+export declare const registerWindows: (moduleClass: Constructor, metadata: RgModuleMetadata) => Promise<void>;

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

@@ -0,0 +1,15 @@
+import { container } from "../container.js";
+export const registerWindows = async (moduleClass, metadata) => {
+    if (!metadata.windows) {
+        return;
+    }
+    for (const windowClass of metadata.windows) {
+        const windowMetadataValue = Reflect.getMetadata("WindowManager", windowClass);
+        if (windowMetadataValue?.hash) {
+            container.addProvider(moduleClass, windowMetadataValue.hash, {
+                metadata: windowMetadataValue,
+                windowClass,
+            });
+        }
+    }
+};

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

@@ -0,0 +1,11 @@
+export type TFolderSettings = {
+    distRenderer: string;
+    distMain: string;
+};
+export type TSettings = {
+    baseRestApi: string;
+    localhostPort: string;
+    folders: TFolderSettings;
+};
+export declare const initSettings: (options: TSettings) => void;
+export declare const getSettings: () => TSettings;

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

@@ -0,0 +1,13 @@
+import { SettingsNotInitializedError } from "../errors/index.js";
+const KEY = "settings";
+const settings = new Map();
+export const initSettings = (options) => {
+    settings.set(KEY, options);
+};
+export const getSettings = () => {
+    const cachedSettings = settings.get(KEY);
+    if (!cachedSettings) {
+        throw new SettingsNotInitializedError();
+    }
+    return cachedSettings;
+};

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

@@ -0,0 +1,26 @@
+import type { Constructor } from "./types/constructor.js";
+import type { RgModuleMetadata } from "./types/module-metadata.js";
+import type { TProviderToken } from "./types/provider.js";
+export declare class Container {
+    private readonly modules;
+    private readonly moduleMetadata;
+    private readonly instances;
+    private readonly resolutionCache;
+    addModule(moduleClass: Constructor, metadata: Pick<RgModuleMetadata, "exports" | "providers">): boolean;
+    setModuleMetadata(moduleClass: Constructor, metadata: RgModuleMetadata): void;
+    hasModule(moduleClass: Constructor): boolean;
+    private getCacheKey;
+    addProvider(moduleClass: Constructor, provider: TProviderToken, instance?: unknown): void;
+    getProvider<T = unknown>(moduleClass: Constructor, token: TProviderToken): T | undefined;
+    getModuleExports(moduleClass: Constructor): Set<TProviderToken>;
+    getModuleMetadata(moduleClass: Constructor): RgModuleMetadata | undefined;
+    registerInstance(token: TProviderToken, instance: unknown): void;
+    resolve<T>(moduleClass: Constructor, token: TProviderToken): Promise<T | undefined>;
+    private resolveFromImports;
+    private instantiateProvider;
+    private instantiateFactoryProvider;
+    private instantiateClassProvider;
+    private instantiateClassConstructor;
+    private resolveDependencies;
+}
+export declare const container: Container;

package/dist/@core/container.js

@@ -0,0 +1,154 @@
+import { getDependencyTokens } from "./utils/dependency-tokens.js";
+import { ModuleNotRegisteredError, ProviderNotFoundError, } from "./errors/index.js";
+export class Container {
+    modules = new Map();
+    moduleMetadata = new Map();
+    instances = new Map();
+    resolutionCache = new Map();
+    addModule(moduleClass, metadata) {
+        if (this.modules.has(moduleClass)) {
+            return false;
+        }
+        this.modules.set(moduleClass, {
+            providers: new Map(),
+            exports: new Set(metadata.exports ?? []),
+        });
+        return true;
+    }
+    setModuleMetadata(moduleClass, metadata) {
+        this.moduleMetadata.set(moduleClass, metadata);
+    }
+    hasModule(moduleClass) {
+        return this.modules.has(moduleClass);
+    }
+    getCacheKey(moduleClass, token) {
+        const tokenKey = typeof token === "string" || typeof token === "symbol"
+            ? String(token)
+            : token.name;
+        return `${moduleClass.name}:${tokenKey}`;
+    }
+    addProvider(moduleClass, provider, instance) {
+        const moduleData = this.modules.get(moduleClass);
+        if (!moduleData) {
+            throw new ModuleNotRegisteredError(moduleClass.name);
+        }
+        moduleData.providers.set(provider, instance ?? provider);
+    }
+    getProvider(moduleClass, token) {
+        const moduleData = this.modules.get(moduleClass);
+        if (!moduleData) {
+            return undefined;
+        }
+        return moduleData.providers.get(token);
+    }
+    getModuleExports(moduleClass) {
+        const moduleData = this.modules.get(moduleClass);
+        return moduleData?.exports ?? new Set();
+    }
+    getModuleMetadata(moduleClass) {
+        return this.moduleMetadata.get(moduleClass);
+    }
+    registerInstance(token, instance) {
+        this.instances.set(token, instance);
+    }
+    async resolve(moduleClass, token) {
+        const cacheKey = this.getCacheKey(moduleClass, token);
+        if (this.resolutionCache.has(cacheKey)) {
+            return this.resolutionCache.get(cacheKey);
+        }
+        if (this.instances.has(token)) {
+            const instance = this.instances.get(token);
+            this.resolutionCache.set(cacheKey, instance);
+            return instance;
+        }
+        const provider = this.getProvider(moduleClass, token);
+        if (!provider) {
+            const resolvedFromImports = await this.resolveFromImports(moduleClass, token);
+            if (resolvedFromImports !== undefined) {
+                this.resolutionCache.set(cacheKey, resolvedFromImports);
+                return resolvedFromImports;
+            }
+            if (token !== moduleClass) {
+                throw new ProviderNotFoundError(String(token), moduleClass.name);
+            }
+            return undefined;
+        }
+        const instance = await this.instantiateProvider(moduleClass, token, provider);
+        if (instance !== undefined) {
+            this.resolutionCache.set(cacheKey, instance);
+        }
+        return instance;
+    }
+    async resolveFromImports(moduleClass, token) {
+        const moduleMetadata = this.getModuleMetadata(moduleClass);
+        if (!moduleMetadata?.imports) {
+            return undefined;
+        }
+        for (const importedModuleClass of moduleMetadata.imports) {
+            const exportedProviders = this.getModuleExports(importedModuleClass);
+            if (exportedProviders.has(token)) {
+                const exportedProvider = this.getProvider(importedModuleClass, token);
+                if (exportedProvider !== undefined) {
+                    return this.resolve(importedModuleClass, token);
+                }
+            }
+        }
+        return undefined;
+    }
+    async instantiateProvider(moduleClass, token, provider) {
+        const isObj = typeof provider === "object" &&
+            provider !== null &&
+            "provide" in provider;
+        if (isObj &&
+            "useFactory" in provider &&
+            typeof provider.useFactory === "function") {
+            return this.instantiateFactoryProvider(moduleClass, token, provider);
+        }
+        if (isObj &&
+            "useClass" in provider &&
+            typeof provider.useClass === "function") {
+            return this.instantiateClassProvider(moduleClass, token, provider);
+        }
+        if (isObj && "useValue" in provider) {
+            const val = provider.useValue;
+            this.instances.set(token, val);
+            return val;
+        }
+        if (isObj && "useExisting" in provider) {
+            const instance = await this.resolve(moduleClass, provider.useExisting);
+            if (instance !== undefined) {
+                this.instances.set(token, instance);
+            }
+            return instance;
+        }
+        if (typeof provider === "function") {
+            return this.instantiateClassConstructor(moduleClass, token, provider);
+        }
+        return provider;
+    }
+    async instantiateFactoryProvider(moduleClass, token, provider) {
+        const dependencies = provider.inject ?? [];
+        const resolvedDependencies = await this.resolveDependencies(moduleClass, dependencies);
+        const instance = provider.useFactory(...resolvedDependencies);
+        this.instances.set(token, instance);
+        return instance;
+    }
+    async instantiateClassProvider(moduleClass, token, provider) {
+        const dependencies = provider.inject ?? getDependencyTokens(provider.useClass);
+        const resolvedDependencies = await this.resolveDependencies(moduleClass, dependencies);
+        const instance = new provider.useClass(...resolvedDependencies);
+        this.instances.set(token, instance);
+        return instance;
+    }
+    async instantiateClassConstructor(moduleClass, token, providerClass) {
+        const dependencies = getDependencyTokens(providerClass);
+        const resolvedDependencies = await this.resolveDependencies(moduleClass, dependencies);
+        const instance = new providerClass(...resolvedDependencies);
+        this.instances.set(token, instance);
+        return instance;
+    }
+    async resolveDependencies(moduleClass, dependencies) {
+        return Promise.all(dependencies.map((dep) => this.resolve(moduleClass, dep)));
+    }
+}
+export const container = new Container();

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

@@ -0,0 +1 @@
+export declare const cacheWindows: Map<string, Electron.CrossProcessExports.BrowserWindow>;

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

@@ -0,0 +1 @@
+export const cacheWindows = new Map();

package/dist/@core/control-window/create.d.ts

@@ -0,0 +1,3 @@
+import { BrowserWindow } from "electron";
+import type { TParamsCreateWindow } from "./types.js";
+export declare const createWindow: <N extends string>({ hash, options, isCache, loadURL, }: TParamsCreateWindow<N>) => BrowserWindow;

package/dist/@core/control-window/create.js

@@ -0,0 +1,63 @@
+import { BrowserWindow, session, app } from "electron";
+import path from "node:path";
+import { cacheWindows } from "./cache.js";
+import { getWindow } from "./receive.js";
+import { getSettings } from "../bootstrap/settings.js";
+const setupCSP = (base, dev) => {
+    const csp = `default-src 'self'; connect-src 'self' ${base}; img-src * data:; style-src 'self' 'unsafe-inline'; script-src 'self' ${dev ? "'unsafe-inline'" : ""};`
+        .replace(/\s{2,}/g, " ")
+        .trim();
+    session.defaultSession.webRequest.onHeadersReceived((d, cb) => {
+        cb({
+            responseHeaders: {
+                ...d.responseHeaders,
+                "Content-Security-Policy": [csp],
+            },
+        });
+    });
+};
+export const createWindow = ({ hash, options, isCache, loadURL, }) => {
+    const settings = getSettings();
+    const isDev = process.env.NODE_ENV === "development";
+    const ui = path.join(app.getAppPath(), `/${settings.folders.distRenderer}/index.html`);
+    const preload = path.join(app.getAppPath(), isDev ? "." : "..", `/${settings.folders.distMain}/preload.cjs`);
+    if (!settings.baseRestApi)
+        console.warn('Warning: You have to add an environment variable called "process.env.BASE_REST_API"!');
+    if (!settings.localhostPort)
+        console.warn('Warning: You have to add an environment variable called "process.env.LOCALHOST_ELECTRON_SERVER_PORT"!');
+    if (hash && isCache) {
+        const existing = getWindow(hash);
+        if (existing) {
+            existing.show();
+            return existing;
+        }
+    }
+    const win = new BrowserWindow({
+        ...options,
+        webPreferences: {
+            preload,
+            contextIsolation: true,
+            nodeIntegration: false,
+            ...options?.webPreferences,
+        },
+    });
+    if (isCache && !loadURL)
+        setupCSP(settings.baseRestApi, isDev);
+    if (loadURL) {
+        win.loadURL(loadURL);
+    }
+    else if (isDev) {
+        win.loadURL(`http://localhost:${settings.localhostPort}${hash ? `#${hash}` : ""}`);
+    }
+    else if (hash) {
+        win.loadFile(ui, { hash });
+    }
+    if (hash && isCache) {
+        cacheWindows.set(hash, win);
+        win.on("close", (e) => {
+            e.preventDefault();
+            win.hide();
+        });
+    }
+    return win;
+};

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

@@ -0,0 +1 @@
+export declare const destroyWindows: () => void;

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

@@ -0,0 +1,9 @@
+import { BrowserWindow } from "electron";
+export const destroyWindows = () => {
+    const windows = BrowserWindow.getAllWindows();
+    for (const window of windows) {
+        if (!window.isDestroyed()) {
+            window.destroy();
+        }
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { BrowserWindow } from "electron";
+export declare const getWindow: <N extends string>(name: N) => BrowserWindow | undefined;

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

@@ -0,0 +1,8 @@
+import { cacheWindows } from "./cache.js";
+export const getWindow = (name) => {
+    const win = cacheWindows.get(name);
+    if (!win || typeof win === "boolean" || win.isDestroyed()) {
+        return undefined;
+    }
+    return win;
+};

package/dist/@core/control-window/types.d.ts

@@ -0,0 +1,14 @@
+import { BrowserWindow, type BrowserWindowConstructorOptions } from "electron";
+export type TParamsRoute = {
+    [key: string]: string;
+};
+export type TParamsCreateWindow<N = string> = {
+    hash?: N;
+    isCache?: boolean;
+    paramsRoute?: TParamsRoute;
+    options?: BrowserWindowConstructorOptions;
+    loadURL?: string;
+};
+export type TCache = {
+    [key in string]: BrowserWindow;
+};

package/dist/@core/control-window/types.js

@@ -0,0 +1 @@
+import { BrowserWindow } from "electron";