@_traeop_/electron-modular 1.0.6 → 1.0.8

package/README.md

@@ -14,9 +14,45 @@ The package is a dependency injection framework for Electron main process. It us
 
 ---
 
+## Installation
+
+Install with your package manager:
+
+```bash
+# npm
+npm install @_traeop_/electron-modular
+
+# yarn
+yarn add @_traeop_/electron-modular
+
+# pnpm
+pnpm add @_traeop_/electron-modular
+```
+
+Peer dependency:
+
+This package targets Electron's main process and declares Electron >=36 as a peer dependency. Ensure Electron is installed in your project:
+
+```bash
+npm install --save-dev electron@^36
+```
+
+TypeScript setup:
+
+- Enable decorators and metadata in your `tsconfig.json`:
+
+```json
+"experimentalDecorators": true,
+"emitDecoratorMetadata": true
+```
+
+> Tip: This package is published as ESM. When importing local modules, use `.js` extensions in runtime imports, e.g. `import { UserModule } from "./user/module.js"`.
+
+---
+
 ## Quick Start
 
-### 1. Bootstrap Application `app.ts`
+### 1. Bootstrap Application `main.ts`
 
 Initialize the framework and bootstrap all modules:
 
@@ -465,6 +501,10 @@ const window = await mainWindow.create();
 Destroys all cached windows.
 
 ```typescript
+...
+import { destroyWindows } from "@_traeop_/electron-modular";
+...
+
 app.on("before-quit", () => {
   destroyWindows();
 });

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

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

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

@@ -18,4 +18,3 @@ export const bootstrapModules = async (modulesClass) => {
         await initializeIpcHandlers(moduleClass, metadata);
     }
 };
-//# sourceMappingURL=bootstrap.js.map

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

@@ -1,4 +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>;
-//# sourceMappingURL=handlers.d.ts.map

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

@@ -45,4 +45,3 @@ export const initializeIpcHandlers = async (moduleClass, metadata) => {
         }
     }
 };
-//# sourceMappingURL=handlers.js.map

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

@@ -1,4 +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;
-//# sourceMappingURL=window-creator.d.ts.map

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

@@ -26,4 +26,3 @@ export const createWindowWithParams = (baseMetadata, params) => {
         : baseMetadata;
     return createWindow(mergedSettings);
 };
-//# sourceMappingURL=window-creator.js.map

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

@@ -1,4 +1,3 @@
 import type { BrowserWindow } from "electron";
 import type { TWindowManagerWithHandlers } from "../../types/window-manager.js";
-export declare const attachWindowEventListeners: (browserWindow: BrowserWindow, windowInstance: TWindowManagerWithHandlers) => void;
-//# sourceMappingURL=window-event-listeners.d.ts.map
+export declare const attachWindowEventListeners: (win: BrowserWindow, inst: TWindowManagerWithHandlers) => void;

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

@@ -1,91 +1,61 @@
 const windowListeners = new WeakMap();
-const EVENT_PREFIX = "on";
-const WINDOW_PREFIX = "onWindow";
-const WEB_CONTENTS_PREFIX = "onWebContents";
 const getPrototypeMethodNames = (instance) => {
     const names = new Set();
     let proto = Object.getPrototypeOf(instance);
     while (proto && proto !== Object.prototype) {
-        Object.getOwnPropertyNames(proto).forEach((name) => {
-            if (name !== "constructor") {
-                names.add(name);
-            }
-        });
+        Object.getOwnPropertyNames(proto).forEach((n) => n !== "constructor" && names.add(n));
         proto = Object.getPrototypeOf(proto);
     }
     return Array.from(names);
 };
-const toEventName = (handlerName) => {
-    const cleaned = handlerName
-        .replace(WINDOW_PREFIX, "")
-        .replace(WEB_CONTENTS_PREFIX, "")
-        .replace(EVENT_PREFIX, "");
-    return cleaned
+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 isHandlerName = (name) => {
-    return name.startsWith(EVENT_PREFIX);
-};
-const isWebContentsHandler = (name) => {
-    return name.startsWith(WEB_CONTENTS_PREFIX);
-};
-const addListener = (emitter, eventName, listener) => {
-    emitter.on(eventName, listener);
-    return () => {
-        if (emitter.off) {
-            emitter.off(eventName, listener);
-        }
-        else if (emitter.removeListener) {
-            emitter.removeListener(eventName, listener);
-        }
-    };
-};
-const attachHandlersToEmitter = (emitter, browserWindow, windowInstance, handlerNames, filter) => {
+const attachHandlersToEmitter = (emitter, win, inst, names, filter) => {
     const cleanups = [];
-    for (const handlerName of handlerNames) {
-        if (!filter(handlerName)) {
+    for (const name of names) {
+        if (!filter(name))
             continue;
-        }
-        const handler = windowInstance[handlerName];
-        if (typeof handler !== "function") {
+        const h = inst[name];
+        if (typeof h !== "function")
             continue;
-        }
-        const eventName = toEventName(handlerName);
+        const evt = toEventName(name);
         const listener = (...args) => {
-            if (handler.length <= 1) {
-                handler.apply(windowInstance, [browserWindow]);
-            }
-            else {
-                handler.apply(windowInstance, [...args, browserWindow]);
-            }
+            h.length <= 1 ? h.apply(inst, [win]) : h.apply(inst, [...args, win]);
         };
-        cleanups.push(addListener(emitter, eventName, listener));
+        emitter.on(evt, listener);
+        cleanups.push(() => {
+            emitter.off
+                ? emitter.off(evt, listener)
+                : emitter.removeListener &&
+                    emitter.removeListener(evt, listener);
+        });
     }
     return cleanups;
 };
-export const attachWindowEventListeners = (browserWindow, windowInstance) => {
-    const entry = windowListeners.get(browserWindow);
-    if (entry?.instance === windowInstance) {
+export const attachWindowEventListeners = (win, inst) => {
+    const entry = windowListeners.get(win);
+    if (entry?.instance === inst)
         return;
-    }
-    if (entry) {
-        entry.cleanup.forEach((cleanup) => cleanup());
-    }
-    const handlerNames = getPrototypeMethodNames(windowInstance).filter(isHandlerName);
-    const windowCleanups = attachHandlersToEmitter(browserWindow, browserWindow, windowInstance, handlerNames, (name) => !isWebContentsHandler(name));
-    const webContentsCleanups = attachHandlersToEmitter(browserWindow.webContents, browserWindow, windowInstance, handlerNames, isWebContentsHandler);
-    windowListeners.set(browserWindow, {
-        instance: windowInstance,
-        cleanup: [...windowCleanups, ...webContentsCleanups],
+    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],
     });
-    browserWindow.once("closed", () => {
-        const existing = windowListeners.get(browserWindow);
-        if (existing) {
-            existing.cleanup.forEach((cleanup) => cleanup());
-            windowListeners.delete(browserWindow);
+    win.once("closed", () => {
+        const e = windowListeners.get(win);
+        if (e) {
+            e.cleanup.forEach((c) => c());
+            windowListeners.delete(win);
         }
     });
 };
-//# sourceMappingURL=window-event-listeners.js.map

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

@@ -1,4 +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>;
-//# sourceMappingURL=window-instance-creator.d.ts.map

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

@@ -8,4 +8,3 @@ export const createWindowInstance = async (moduleClass, windowClass) => {
     const resolvedDependencies = await Promise.all(dependenciesTypes.map((depType) => container.resolve(moduleClass, depType)));
     return new windowClass(...resolvedDependencies);
 };
-//# sourceMappingURL=window-instance-creator.js.map

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

@@ -1,4 +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>;
-//# sourceMappingURL=initialize-module.d.ts.map

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

@@ -16,4 +16,3 @@ export const initializeModule = async (moduleClass, metadata) => {
         registerIpcHandlers(moduleClass, metadata),
     ]);
 };
-//# sourceMappingURL=initialize-module.js.map

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

@@ -1,3 +1,2 @@
 import type { Constructor } from "../types/constructor.js";
 export declare const instantiateModule: (moduleClass: Constructor) => Promise<unknown>;
-//# sourceMappingURL=instantiate-module.d.ts.map

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

@@ -7,4 +7,3 @@ export const instantiateModule = async (moduleClass) => {
     container.registerInstance(moduleClass, instance);
     return instance;
 };
-//# sourceMappingURL=instantiate-module.js.map

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

@@ -1,3 +1,2 @@
 import type { RgModuleMetadata } from "../types/module-metadata.js";
 export declare const registerImports: (metadata: RgModuleMetadata) => Promise<void>;
-//# sourceMappingURL=register-imports.d.ts.map

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

@@ -10,4 +10,3 @@ export const registerImports = async (metadata) => {
         }
     }
 };
-//# sourceMappingURL=register-imports.js.map

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

@@ -1,4 +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>;
-//# sourceMappingURL=register-ipc-handlers.d.ts.map

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

@@ -7,4 +7,3 @@ export const registerIpcHandlers = async (moduleClass, metadata) => {
         container.addProvider(moduleClass, ipcClass);
     }
 };
-//# sourceMappingURL=register-ipc-handlers.js.map

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

@@ -1,4 +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>;
-//# sourceMappingURL=register-providers.d.ts.map

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

@@ -19,4 +19,3 @@ export const registerProviders = async (moduleClass, metadata) => {
         throw new InvalidProviderError(moduleClass.name);
     }
 };
-//# sourceMappingURL=register-providers.js.map

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

@@ -1,4 +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>;
-//# sourceMappingURL=register-windows.d.ts.map

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

@@ -13,4 +13,3 @@ export const registerWindows = async (moduleClass, metadata) => {
         }
     }
 };
-//# sourceMappingURL=register-windows.js.map

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

@@ -9,4 +9,3 @@ export type TSettings = {
 };
 export declare const initSettings: (options: TSettings) => void;
 export declare const getSettings: () => TSettings;
-//# sourceMappingURL=settings.d.ts.map

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

@@ -11,4 +11,3 @@ export const getSettings = () => {
     }
     return cachedSettings;
 };
-//# sourceMappingURL=settings.js.map

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

@@ -22,11 +22,5 @@ export declare class Container {
     private instantiateClassProvider;
     private instantiateClassConstructor;
     private resolveDependencies;
-    private isProviderObject;
-    private isFactoryProvider;
-    private isClassProvider;
-    private isValueProvider;
-    private isExistingProvider;
 }
 export declare const container: Container;
-//# sourceMappingURL=container.d.ts.map

package/dist/@core/container.js

@@ -96,17 +96,25 @@ export class Container {
         return undefined;
     }
     async instantiateProvider(moduleClass, token, provider) {
-        if (this.isFactoryProvider(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 (this.isClassProvider(provider)) {
+        if (isObj &&
+            "useClass" in provider &&
+            typeof provider.useClass === "function") {
             return this.instantiateClassProvider(moduleClass, token, provider);
         }
-        if (this.isValueProvider(provider)) {
-            this.instances.set(token, provider.useValue);
-            return provider.useValue;
+        if (isObj && "useValue" in provider) {
+            const val = provider.useValue;
+            this.instances.set(token, val);
+            return val;
         }
-        if (this.isExistingProvider(provider)) {
+        if (isObj && "useExisting" in provider) {
             const instance = await this.resolve(moduleClass, provider.useExisting);
             if (instance !== undefined) {
                 this.instances.set(token, instance);
@@ -142,25 +150,5 @@ export class Container {
     async resolveDependencies(moduleClass, dependencies) {
         return Promise.all(dependencies.map((dep) => this.resolve(moduleClass, dep)));
     }
-    isProviderObject(provider) {
-        return (typeof provider === "object" && provider !== null && "provide" in provider);
-    }
-    isFactoryProvider(provider) {
-        return (this.isProviderObject(provider) &&
-            "useFactory" in provider &&
-            typeof provider.useFactory === "function");
-    }
-    isClassProvider(provider) {
-        return (this.isProviderObject(provider) &&
-            "useClass" in provider &&
-            typeof provider.useClass === "function");
-    }
-    isValueProvider(provider) {
-        return this.isProviderObject(provider) && "useValue" in provider;
-    }
-    isExistingProvider(provider) {
-        return this.isProviderObject(provider) && "useExisting" in provider;
-    }
 }
 export const container = new Container();
-//# sourceMappingURL=container.js.map

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

@@ -1,2 +1 @@
 export declare const cacheWindows: Map<string, Electron.CrossProcessExports.BrowserWindow>;
-//# sourceMappingURL=cache.d.ts.map

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

@@ -1,2 +1 @@
 export const cacheWindows = new Map();
-//# sourceMappingURL=cache.js.map

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

@@ -1,4 +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;
-//# sourceMappingURL=create.d.ts.map

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

@@ -3,80 +3,61 @@ import path from "node:path";
 import { cacheWindows } from "./cache.js";
 import { getWindow } from "./receive.js";
 import { getSettings } from "../bootstrap/settings.js";
-const createContentSecurityPolicy = (baseRestApi, isDev) => {
-    const csp = `
-    default-src 'self';
-    connect-src 'self' ${baseRestApi};
-    img-src * data:;
-    style-src 'self' 'unsafe-inline';
-    script-src 'self' ${isDev ? "'unsafe-inline'" : ""};
-  `
+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();
-    return csp;
-};
-const setupContentSecurityPolicy = (baseRestApi, isDev) => {
-    const csp = createContentSecurityPolicy(baseRestApi, isDev);
-    session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
-        callback({
+    session.defaultSession.webRequest.onHeadersReceived((d, cb) => {
+        cb({
             responseHeaders: {
-                ...details.responseHeaders,
+                ...d.responseHeaders,
                 "Content-Security-Policy": [csp],
             },
         });
     });
 };
-const getAppPaths = (settings, isDev) => {
-    return {
-        ui: path.join(app.getAppPath(), `/${settings.folders.distRenderer}/index.html`),
-        preload: path.join(app.getAppPath(), isDev ? "." : "..", `/${settings.folders.distMain}/preload.cjs`),
-    };
-};
 export const createWindow = ({ hash, options, isCache, loadURL, }) => {
     const settings = getSettings();
     const isDev = process.env.NODE_ENV === "development";
-    const { ui: uiPath, preload: preloadPath } = getAppPaths(settings, isDev);
-    if (!settings.baseRestApi) {
+    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) {
+    if (!settings.localhostPort)
         console.warn('Warning: You have to add an environment variable called "process.env.LOCALHOST_ELECTRON_SERVER_PORT"!');
-    }
     if (hash && isCache) {
-        const existingWindow = getWindow(hash);
-        if (existingWindow) {
-            existingWindow.show();
-            return existingWindow;
+        const existing = getWindow(hash);
+        if (existing) {
+            existing.show();
+            return existing;
         }
     }
-    const newWindow = new BrowserWindow({
+    const win = new BrowserWindow({
         ...options,
         webPreferences: {
-            preload: preloadPath,
+            preload,
             contextIsolation: true,
             nodeIntegration: false,
             ...options?.webPreferences,
         },
     });
-    if (isCache && !loadURL) {
-        setupContentSecurityPolicy(settings.baseRestApi, isDev);
-    }
+    if (isCache && !loadURL)
+        setupCSP(settings.baseRestApi, isDev);
     if (loadURL) {
-        newWindow.loadURL(loadURL);
+        win.loadURL(loadURL);
     }
     else if (isDev) {
-        newWindow.loadURL(`http://localhost:${settings.localhostPort}${hash ? `#${hash}` : ""}`);
+        win.loadURL(`http://localhost:${settings.localhostPort}${hash ? `#${hash}` : ""}`);
     }
     else if (hash) {
-        newWindow.loadFile(uiPath, { hash });
+        win.loadFile(ui, { hash });
     }
     if (hash && isCache) {
-        cacheWindows.set(hash, newWindow);
-        newWindow.on("close", (event) => {
-            event.preventDefault();
-            newWindow.hide();
+        cacheWindows.set(hash, win);
+        win.on("close", (e) => {
+            e.preventDefault();
+            win.hide();
         });
     }
-    return newWindow;
+    return win;
 };
-//# sourceMappingURL=create.js.map

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

@@ -1,2 +1 @@
 export declare const destroyWindows: () => void;
-//# sourceMappingURL=destroy.d.ts.map

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

@@ -7,4 +7,3 @@ export const destroyWindows = () => {
         }
     }
 };
-//# sourceMappingURL=destroy.js.map

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

@@ -1,3 +1,2 @@
 import type { BrowserWindow } from "electron";
 export declare const getWindow: <N extends string>(name: N) => BrowserWindow | undefined;
-//# sourceMappingURL=receive.d.ts.map

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

@@ -6,4 +6,3 @@ export const getWindow = (name) => {
     }
     return win;
 };
-//# sourceMappingURL=receive.js.map

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

@@ -12,4 +12,3 @@ export type TParamsCreateWindow<N = string> = {
 export type TCache = {
     [key in string]: BrowserWindow;
 };
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,2 +1 @@
 import { BrowserWindow } from "electron";
-//# sourceMappingURL=types.js.map

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

@@ -4,4 +4,3 @@ type TInjectTokensMetadata = Record<number, TProviderToken>;
 export declare const Inject: (token: TProviderToken) => ParameterDecorator;
 export declare const getInjectedTokens: (target: Function) => TInjectTokensMetadata;
 export {};
-//# sourceMappingURL=inject.d.ts.map

package/dist/@core/decorators/inject.js

@@ -13,4 +13,3 @@ export const Inject = (token) => {
 export const getInjectedTokens = (target) => {
     return Reflect.getMetadata(INJECT_TOKENS_METADATA_KEY, target) ?? {};
 };
-//# sourceMappingURL=inject.js.map

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

@@ -1,3 +1,2 @@
 import "reflect-metadata/lite";
 export declare const Injectable: () => ClassDecorator;
-//# sourceMappingURL=injectable.d.ts.map

package/dist/@core/decorators/injectable.js

@@ -4,4 +4,3 @@ export const Injectable = () => {
         Reflect.defineMetadata("Injectable", true, target);
     };
 };
-//# sourceMappingURL=injectable.js.map

package/dist/@core/decorators/ipc-handler.d.ts

@@ -1,3 +1,2 @@
 import "reflect-metadata/lite";
 export declare const IpcHandler: () => ClassDecorator;
-//# sourceMappingURL=ipc-handler.d.ts.map

package/dist/@core/decorators/ipc-handler.js

@@ -4,4 +4,3 @@ export const IpcHandler = () => {
         Reflect.defineMetadata("IpcHandler", true, target);
     };
 };
-//# sourceMappingURL=ipc-handler.js.map

package/dist/@core/decorators/rg-module.d.ts

@@ -1,4 +1,3 @@
 import "reflect-metadata/lite";
 import type { RgModuleMetadata } from "../types/module-metadata.js";
 export declare const RgModule: (options: RgModuleMetadata) => ClassDecorator;
-//# sourceMappingURL=rg-module.d.ts.map

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

@@ -4,4 +4,3 @@ export const RgModule = (options) => {
         Reflect.defineMetadata("RgModule", options, target);
     };
 };
-//# sourceMappingURL=rg-module.js.map

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

@@ -1,4 +1,3 @@
 import "reflect-metadata/lite";
 import type { TParamsCreateWindow } from "../control-window/types.js";
 export declare const WindowManager: <P extends string>(options: TParamsCreateWindow<P>) => ClassDecorator;
-//# sourceMappingURL=window-manager.d.ts.map

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

@@ -4,4 +4,3 @@ export const WindowManager = (options) => {
         Reflect.defineMetadata("WindowManager", options, target);
     };
 };
-//# sourceMappingURL=window-manager.js.map