@devisfuture/electron-modular 1.2.16 → 1.2.18

package/dist/@core/bootstrap/register-lazy-module.js

@@ -1,48 +0,0 @@
-import { ipcMain } from "electron";
-import { initializeModule } from "./initialize-module.js";
-import { instantiateModule } from "./instantiate-module.js";
-import { container } from "../container.js";
-import { initializeIpcHandlers } from "./initialize-ipc/handlers.js";
-import { InvalidLazyTriggerError } from "../errors/index.js";
-const getValidLazyTrigger = (moduleClass, metadata) => {
-    const trigger = metadata.lazy?.trigger;
-    if (typeof trigger !== "string" || trigger.trim().length === 0) {
-        throw new InvalidLazyTriggerError(moduleClass.name);
-    }
-    return trigger.trim();
-};
-export const registerLazyModule = (moduleClass, metadata) => {
-    const trigger = getValidLazyTrigger(moduleClass, metadata);
-    let initPromise = null;
-    ipcMain.handle(trigger, async () => {
-        if (initPromise) {
-            return initPromise;
-        }
-        initPromise = (async () => {
-            try {
-                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);
-                return {
-                    initialized: true,
-                    name: trigger,
-                };
-            }
-            catch (error) {
-                initPromise = null;
-                return {
-                    initialized: false,
-                    name: trigger,
-                    error: {
-                        message: error instanceof Error ? error.message : String(error),
-                    },
-                };
-            }
-        })();
-        return initPromise;
-    });
-};

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

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

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

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

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

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

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

@@ -1,13 +0,0 @@
-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/bootstrap/validate-lazy-constraints.d.ts

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

package/dist/@core/bootstrap/validate-lazy-constraints.js

@@ -1,18 +0,0 @@
-import { LazyModuleCannotImportLazyModuleError, LazyModuleExportsNotAllowedError, } from "../errors/index.js";
-export const validateLazyConstraints = (moduleClass, metadata) => {
-    if (!metadata.lazy?.enabled) {
-        return;
-    }
-    if ((metadata.exports?.length ?? 0) > 0) {
-        throw new LazyModuleExportsNotAllowedError(moduleClass.name);
-    }
-    if (!metadata.imports?.length) {
-        return;
-    }
-    for (const importedModuleClass of metadata.imports) {
-        const importedModuleMetadata = Reflect.getMetadata("RgModule", importedModuleClass);
-        if (importedModuleMetadata?.lazy?.enabled) {
-            throw new LazyModuleCannotImportLazyModuleError(moduleClass.name, importedModuleClass.name);
-        }
-    }
-};

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

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

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

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

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

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

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

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

@@ -1,62 +0,0 @@
-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 = (sources, dev) => {
-    const connectSrc = sources.length > 0 ? ` ${sources.join(" ")}` : "";
-    const csp = `default-src 'self'; connect-src 'self'${connectSrc}; 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.localhostPort)
-        console.warn('Warning: You have to add an environment variable for example 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 && settings.cspConnectSources)
-        setupCSP(settings.cspConnectSources, 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

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

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

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

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-import "reflect-metadata/lite";
-import type { TProviderToken } from "../types/provider.js";
-type TInjectTokensMetadata = Record<number, TProviderToken>;
-export declare const Inject: (token: TProviderToken) => ParameterDecorator;
-export declare const getInjectedTokens: (target: Function) => TInjectTokensMetadata;
-export {};

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

@@ -1,15 +0,0 @@
-import "reflect-metadata/lite";
-const INJECT_TOKENS_METADATA_KEY = "RgInjectTokens";
-export const Inject = (token) => {
-    return (target, propertyKey, parameterIndex) => {
-        if (propertyKey !== undefined) {
-            return;
-        }
-        const existingTokens = Reflect.getMetadata(INJECT_TOKENS_METADATA_KEY, target) ?? {};
-        existingTokens[parameterIndex] = token;
-        Reflect.defineMetadata(INJECT_TOKENS_METADATA_KEY, existingTokens, target);
-    };
-};
-export const getInjectedTokens = (target) => {
-    return Reflect.getMetadata(INJECT_TOKENS_METADATA_KEY, target) ?? {};
-};

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

@@ -1,2 +0,0 @@
-import "reflect-metadata/lite";
-export declare const Injectable: () => ClassDecorator;

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

@@ -1,6 +0,0 @@
-import "reflect-metadata/lite";
-export const Injectable = () => {
-    return (target) => {
-        Reflect.defineMetadata("Injectable", true, target);
-    };
-};

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

@@ -1,2 +0,0 @@
-import "reflect-metadata/lite";
-export declare const IpcHandler: () => ClassDecorator;

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

@@ -1,6 +0,0 @@
-import "reflect-metadata/lite";
-export const IpcHandler = () => {
-    return (target) => {
-        Reflect.defineMetadata("IpcHandler", true, target);
-    };
-};

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

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

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

@@ -1,6 +0,0 @@
-import "reflect-metadata/lite";
-export const RgModule = (options) => {
-    return (target) => {
-        Reflect.defineMetadata("RgModule", options, target);
-    };
-};

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

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

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

@@ -1,6 +0,0 @@
-import "reflect-metadata/lite";
-export const WindowManager = (options) => {
-    return (target) => {
-        Reflect.defineMetadata("WindowManager", options, target);
-    };
-};

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

@@ -1,34 +0,0 @@
-declare class BaseError extends Error {
-    constructor(msg: string, name: string);
-}
-export declare class ModuleNotRegisteredError extends BaseError {
-    constructor(m: string);
-}
-export declare class ProviderNotFoundError extends BaseError {
-    constructor(t: string, m: string);
-}
-export declare class ModuleDecoratorMissingError extends BaseError {
-    constructor(m: string);
-}
-export declare class InvalidProviderError extends BaseError {
-    constructor(m: string);
-}
-export declare class SettingsNotInitializedError extends BaseError {
-    constructor();
-}
-export declare class InvalidLazyTriggerError extends BaseError {
-    constructor(moduleName: string);
-}
-export declare class DuplicateLazyTriggerError extends BaseError {
-    constructor(trigger: string, firstModule: string, secondModule: string);
-}
-export declare class LazyModuleExportsNotAllowedError extends BaseError {
-    constructor(moduleName: string);
-}
-export declare class LazyModuleCannotImportLazyModuleError extends BaseError {
-    constructor(moduleName: string, importedModuleName: string);
-}
-export declare class EagerModuleCannotImportLazyModuleError extends BaseError {
-    constructor(moduleName: string, importedModuleName: string);
-}
-export {};

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

@@ -1,56 +0,0 @@
-class BaseError extends Error {
-    constructor(msg, name) {
-        super(msg);
-        this.name = name;
-    }
-}
-export class ModuleNotRegisteredError extends BaseError {
-    constructor(m) {
-        super(`Module "${m}" is not registered in the container.`, "ModuleNotRegisteredError");
-    }
-}
-export class ProviderNotFoundError extends BaseError {
-    constructor(t, m) {
-        super(`Provider not found for token "${t}" in module "${m}" or its imports.`, "ProviderNotFoundError");
-    }
-}
-export class ModuleDecoratorMissingError extends BaseError {
-    constructor(m) {
-        super(`Module ${m} does not have the @RgModule decorator`, "ModuleDecoratorMissingError");
-    }
-}
-export class InvalidProviderError extends BaseError {
-    constructor(m) {
-        super(`Invalid provider definition registered in module ${m}`, "InvalidProviderError");
-    }
-}
-export class SettingsNotInitializedError extends BaseError {
-    constructor() {
-        super("App settings cache has not been initialized.", "SettingsNotInitializedError");
-    }
-}
-export class InvalidLazyTriggerError extends BaseError {
-    constructor(moduleName) {
-        super(`Invalid lazy trigger in module "${moduleName}". "lazy.trigger" must be a non-empty string.`, "InvalidLazyTriggerError");
-    }
-}
-export class DuplicateLazyTriggerError extends BaseError {
-    constructor(trigger, firstModule, secondModule) {
-        super(`Duplicate lazy trigger "${trigger}" detected in modules "${firstModule}" and "${secondModule}". Each lazy module must use a unique trigger.`, "DuplicateLazyTriggerError");
-    }
-}
-export class LazyModuleExportsNotAllowedError extends BaseError {
-    constructor(moduleName) {
-        super(`Invalid lazy module "${moduleName}". Lazy modules cannot declare exports.`, "LazyModuleExportsNotAllowedError");
-    }
-}
-export class LazyModuleCannotImportLazyModuleError extends BaseError {
-    constructor(moduleName, importedModuleName) {
-        super(`Invalid lazy module "${moduleName}". It cannot import lazy module "${importedModuleName}". Lazy modules can only import eager modules.`, "LazyModuleCannotImportLazyModuleError");
-    }
-}
-export class EagerModuleCannotImportLazyModuleError extends BaseError {
-    constructor(moduleName, importedModuleName) {
-        super(`Invalid eager module "${moduleName}". It cannot import lazy module "${importedModuleName}". Eager modules must import only eager modules.`, "EagerModuleCannotImportLazyModuleError");
-    }
-}

package/dist/@core/types/constructor.d.ts

@@ -1 +0,0 @@
-export type Constructor<T = any> = new (...args: any[]) => T;

package/dist/@core/types/constructor.js

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

package/dist/@core/types/index.d.ts

@@ -1,8 +0,0 @@
-export type { Constructor } from "./constructor.js";
-export type { TIpcHandlerInterface, TParamOnInit } from "./ipc-handler.js";
-export type { RgModuleMetadata } from "./module-metadata.js";
-export type { TProviderToken, TClassProvider, TFactoryProvider, TValueProvider, TExistingProvider, TProvider, } from "./provider.js";
-export type { TWindowFactory, TWindowCreate } from "./window-factory.js";
-export type { WindowManagerOptions, TWindowManagerWithHandlers, } from "./window-manager.js";
-export type { TMetadataWindow } from "./window-metadata.js";
-export type { TLazyConfig, TLazyModuleResponse } from "./lazy.js";

package/dist/@core/types/index.js

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

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

@@ -1,7 +0,0 @@
-import type { TWindowFactory } from "./window-factory.js";
-export type TParamOnInit<N = string> = {
-    getWindow: (name?: N) => TWindowFactory;
-};
-export type TIpcHandlerInterface = {
-    onInit?: (data: TParamOnInit) => void | Promise<void>;
-};

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

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