Window Management

The Electron adapter provides injectable services for managing BrowserWindow instances through Zelt's DI system.

ElectronAdaptor

ElectronAdaptor is a lifecycle service that wraps Electron's core APIs. It resolves after app.whenReady(), giving you safe access to Electron primitives.

@Injectable()
export class AppLifecycleService {
  constructor(private electron = inject(ElectronAdaptor)) {}

  async initialize() {
    const { app, ipcMain, dialog } = this.electron.ready;
  }
}

Available APIs

The ready property exposes:

Property	Type	Description
app	App	Electron app instance
ipcMain	IpcMain	IPC main module
protocol	Protocol	Protocol handler
shell	Shell	Shell integration
screen	Screen	Display info
dialog	Dialog	Native dialogs
Menu	typeof Menu	Menu class
createBrowserWindow	(options) => BrowserWindow	Create a window
getAllWindows	() => BrowserWindow[]	List all windows
fromWebContents	(webContents) => BrowserWindow | null	Find window by web contents
fromId	(id) => BrowserWindow | null	Find window by ID
getFocusedWindow	() => BrowserWindow | null	Get focused window

WindowDefinition

Define windows as data:

const mainWindow: WindowDefinition = {
  id: 'main',
  loadTarget: { type: 'file', path: join(__dirname, '../renderer/index.html') },
  options: {
    width: 900,
    height: 670,
    webPreferences: {
      contextIsolation: true,
      nodeIntegration: false,
      preload: join(__dirname, '../preload/index.js'),
      sandbox: true,
    },
  },
};

WindowLoadTarget

Type	Properties	Description
{ type: 'file' }	path: string	Load a local HTML file
{ type: 'url' }	url: string	Load a URL (useful for dev server)

Creating Windows via DI

Encapsulate window creation in a service:

@Injectable()
export class MainWindow {
  constructor(private env = inject(EnvService)) {}

  create(): WindowDefinition {
    const loadTarget: WindowLoadTarget =
      this.env.isDevelopment && this.env.rendererUrl
        ? { type: 'url', url: this.env.rendererUrl }
        : { type: 'file', path: join(__dirname, '../renderer/index.html') };

    return {
      id: 'main',
      loadTarget,
      options: {
        width: 900,
        height: 670,
        show: false,
        webPreferences: {
          contextIsolation: true,
          nodeIntegration: false,
          preload: join(__dirname, '../preload/index.js'),
          sandbox: true,
        },
      },
    };
  }
}

Window Registry

ElectronWindowRegistryService manages the lifecycle of multiple windows:

@Injectable()
export class WindowManagerService {
  constructor(private registry = inject(ElectronWindowRegistryService)) {}

  openMain(definition: WindowDefinition) {
    const handle = this.registry.open(definition);
    handle.on('ready-to-show', () => handle.show());
    return handle;
  }

  closeAll() {
    this.registry.closeAll();
  }

  get windowCount() {
    return this.registry.count();
  }
}

API

Method	Description
open(definition)	Open a new window or focus an existing one with the same ID
close(id)	Close a specific window
closeAll()	Close all managed windows
count()	Number of open windows

WindowHandle

open() returns a WindowHandle — a safe wrapper around BrowserWindow:

Method	Description
close()	Close the window
focus()	Focus the window
show()	Show the window
isDestroyed()	Check if destroyed
getTitle()	Get window title
getBounds() / setBounds()	Get/set window position and size
loadFile(path) / loadURL(url)	Load content
on(event, handler)	Listen to 'closed' or 'ready-to-show'
webContents.send(channel, ...args)	Send to renderer