@zeltjs/adapter-electron 0.8.1 → 0.8.2-canary.1

package/dist/ipc.types-DgxeccV3.d.cts

@@ -0,0 +1,26 @@
+//#region src/shared/ipc.types.d.ts
+type IpcBody = {
+  kind: 'none';
+} | {
+  kind: 'text';
+  readonly value: string;
+} | {
+  kind: 'arrayBuffer';
+  readonly value: ArrayBuffer;
+};
+type IpcFetchRequest = {
+  readonly method: string;
+  readonly path: string;
+  readonly headers: ReadonlyArray<readonly [string, string]>;
+  readonly body: IpcBody;
+};
+type IpcFetchResponse = {
+  readonly status: number;
+  readonly statusText: string;
+  readonly headers: ReadonlyArray<readonly [string, string]>;
+  readonly body: IpcBody;
+};
+type IpcSender = (request: IpcFetchRequest) => Promise<IpcFetchResponse>;
+//#endregion
+export { IpcFetchResponse as n, IpcSender as r, IpcFetchRequest as t };
+//# sourceMappingURL=ipc.types-DgxeccV3.d.cts.map

package/dist/ipc.types-DgxeccV3.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipc.types-DgxeccV3.d.cts","names":[],"sources":["../src/shared/ipc.types.ts"],"mappings":";KAAY,OAAA;EACN,IAAA;AAAA;EACA,IAAA;EAAA,SAAuB,KAAA;AAAA;EACvB,IAAA;EAAA,SAA8B,KAAA,EAAO,WAAA;AAAA;AAAA,KAE/B,eAAA;EAAA,SACD,MAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA,EAAS,aAAA;EAAA,SACT,IAAA,EAAM,OAAA;AAAA;AAAA,KAGL,gBAAA;EAAA,SACD,MAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA,EAAS,aAAA;EAAA,SACT,IAAA,EAAM,OAAA;AAAA;AAAA,KAGL,SAAA,IAAa,OAAA,EAAS,eAAA,KAAoB,OAAA,CAAQ,gBAAA"}

package/dist/ipc.types-OYZhXKH2.d.ts

@@ -0,0 +1,26 @@
+//#region src/shared/ipc.types.d.ts
+type IpcBody = {
+  kind: 'none';
+} | {
+  kind: 'text';
+  readonly value: string;
+} | {
+  kind: 'arrayBuffer';
+  readonly value: ArrayBuffer;
+};
+type IpcFetchRequest = {
+  readonly method: string;
+  readonly path: string;
+  readonly headers: ReadonlyArray<readonly [string, string]>;
+  readonly body: IpcBody;
+};
+type IpcFetchResponse = {
+  readonly status: number;
+  readonly statusText: string;
+  readonly headers: ReadonlyArray<readonly [string, string]>;
+  readonly body: IpcBody;
+};
+type IpcSender = (request: IpcFetchRequest) => Promise<IpcFetchResponse>;
+//#endregion
+export { IpcFetchResponse as n, IpcSender as r, IpcFetchRequest as t };
+//# sourceMappingURL=ipc.types-OYZhXKH2.d.ts.map

package/dist/ipc.types-OYZhXKH2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipc.types-OYZhXKH2.d.ts","names":[],"sources":["../src/shared/ipc.types.ts"],"mappings":";KAAY,OAAA;EACN,IAAA;AAAA;EACA,IAAA;EAAA,SAAuB,KAAA;AAAA;EACvB,IAAA;EAAA,SAA8B,KAAA,EAAO,WAAA;AAAA;AAAA,KAE/B,eAAA;EAAA,SACD,MAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA,EAAS,aAAA;EAAA,SACT,IAAA,EAAM,OAAA;AAAA;AAAA,KAGL,gBAAA;EAAA,SACD,MAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA,EAAS,aAAA;EAAA,SACT,IAAA,EAAM,OAAA;AAAA;AAAA,KAGL,SAAA,IAAa,OAAA,EAAS,eAAA,KAAoB,OAAA,CAAQ,gBAAA"}

package/dist/main/index.cjs

@@ -0,0 +1,266 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _zeltjs_core = require("@zeltjs/core");
+let ts_pattern = require("ts-pattern");
+//#region src/main/electron.adaptor.ts
+function _ts_decorate$3(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;
+}
+function _ts_metadata$2(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var ElectronAdaptor = class {
+	async startup() {
+		const { app, BrowserWindow: BW, dialog, ipcMain, Menu, protocol, screen, shell } = await import("electron");
+		await app.whenReady();
+		return {
+			app,
+			ipcMain,
+			protocol,
+			shell,
+			screen,
+			dialog,
+			Menu,
+			createBrowserWindow: (options) => new BW(options),
+			getAllWindows: () => BW.getAllWindows(),
+			fromWebContents: (wc) => BW.fromWebContents(wc),
+			fromId: (id) => BW.fromId(id),
+			getFocusedWindow: () => BW.getFocusedWindow()
+		};
+	}
+	shutdown() {
+		this.ready.app.quit();
+	}
+	constructor(lifecycleManager = (0, _zeltjs_core.inject)(_zeltjs_core.LifecycleManager)) {
+		this.ready = lifecycleManager.register(this);
+	}
+};
+ElectronAdaptor = _ts_decorate$3([
+	(0, _zeltjs_core.Injectable)(),
+	_ts_metadata$2("design:type", Function),
+	_ts_metadata$2("design:paramtypes", [void 0])
+], ElectronAdaptor);
+//#endregion
+//#region src/main/electron-env.adaptor.ts
+function _ts_decorate$2(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 ElectronEnvAdaptor = class extends _zeltjs_core.EnvAdaptor {
+	get(key) {
+		return process.env[key];
+	}
+};
+ElectronEnvAdaptor = _ts_decorate$2([_zeltjs_core.Config], ElectronEnvAdaptor);
+//#endregion
+//#region src/main/electron-window-runtime.service.ts
+function _ts_decorate$1(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;
+}
+function _ts_metadata$1(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var ElectronWindowRuntimeService = class {
+	open(definition) {
+		const handle = this.createWindowHandle(this.electronApp.ready.createBrowserWindow(definition.options));
+		if (definition.loadTarget.type === "url") handle.loadURL(definition.loadTarget.url);
+		else handle.loadFile(definition.loadTarget.path);
+		return handle;
+	}
+	createWindowHandle(win) {
+		return {
+			id: win.id,
+			native: win,
+			close: () => win.close(),
+			focus: () => win.focus(),
+			show: () => win.show(),
+			isDestroyed: () => win.isDestroyed(),
+			getTitle: () => win.getTitle(),
+			getBounds: () => win.getBounds(),
+			setBounds: (bounds) => win.setBounds(bounds),
+			loadFile: (path) => {
+				win.loadFile(path);
+			},
+			loadURL: (url) => {
+				win.loadURL(url);
+			},
+			on: (event, handler) => {
+				(0, ts_pattern.match)(event).with("closed", (e) => win.on(e, handler)).with("ready-to-show", (e) => win.on(e, handler)).exhaustive();
+			},
+			removeListener: (event, handler) => {
+				(0, ts_pattern.match)(event).with("closed", (e) => win.removeListener(e, handler)).with("ready-to-show", (e) => win.removeListener(e, handler)).exhaustive();
+			},
+			webContents: {
+				send: (channel, ...args) => win.webContents.send(channel, ...args),
+				setWindowOpenHandler: (handler) => win.webContents.setWindowOpenHandler(handler)
+			}
+		};
+	}
+	constructor(electronApp = (0, _zeltjs_core.inject)(ElectronAdaptor)) {
+		this.electronApp = electronApp;
+	}
+};
+ElectronWindowRuntimeService = _ts_decorate$1([
+	(0, _zeltjs_core.Injectable)(),
+	_ts_metadata$1("design:type", Function),
+	_ts_metadata$1("design:paramtypes", [typeof ElectronAdaptor === "undefined" ? Object : ElectronAdaptor])
+], ElectronWindowRuntimeService);
+//#endregion
+//#region src/main/electron-window-registry.service.ts
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var ElectronWindowRegistryService = class {
+	open(definition) {
+		const existing = this.windows.get(definition.id);
+		if (existing && !existing.isDestroyed()) {
+			existing.focus();
+			return existing;
+		}
+		const handle = this.runtime.open(definition);
+		this.windows.set(definition.id, handle);
+		handle.on("closed", () => {
+			this.windows.delete(definition.id);
+		});
+		return handle;
+	}
+	close(id) {
+		const handle = this.windows.get(id);
+		if (handle && !handle.isDestroyed()) handle.close();
+	}
+	closeAll() {
+		for (const handle of this.windows.values()) if (!handle.isDestroyed()) handle.close();
+	}
+	count() {
+		return this.windows.size;
+	}
+	constructor(runtime = (0, _zeltjs_core.inject)(ElectronWindowRuntimeService)) {
+		this.runtime = runtime;
+		this.windows = /* @__PURE__ */ new Map();
+	}
+};
+ElectronWindowRegistryService = _ts_decorate([
+	(0, _zeltjs_core.Injectable)(),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [void 0])
+], ElectronWindowRegistryService);
+//#endregion
+//#region src/main/ipc-bridge.ts
+const BODY_FORBIDDEN_METHODS = new Set(["GET", "HEAD"]);
+const NO_BODY_STATUSES = new Set([
+	204,
+	205,
+	304
+]);
+const TEXT_CONTENT_TYPE_PREFIXES = [
+	"text/",
+	"application/json",
+	"application/xml",
+	"application/javascript",
+	"application/x-www-form-urlencoded"
+];
+const isTextContentType = (contentType) => TEXT_CONTENT_TYPE_PREFIXES.some((prefix) => contentType.startsWith(prefix));
+const toBody = (body) => (0, ts_pattern.match)(body).with({ kind: "none" }, () => null).with({ kind: "text" }, ({ value }) => value).with({ kind: "arrayBuffer" }, ({ value }) => value).exhaustive();
+const toRequest = (payload, baseUrl) => {
+	const headers = payload.headers.map(([k, v]) => [k, v]);
+	return new Request(baseUrl + payload.path, {
+		method: payload.method,
+		headers,
+		body: BODY_FORBIDDEN_METHODS.has(payload.method) ? null : toBody(payload.body)
+	});
+};
+const toIpcResponse = async (response, method) => {
+	const headers = [];
+	response.headers.forEach((value, key) => {
+		headers.push([key, value]);
+	});
+	let body;
+	if (NO_BODY_STATUSES.has(response.status) || method === "HEAD") body = { kind: "none" };
+	else {
+		const contentType = response.headers.get("content-type");
+		if (contentType && isTextContentType(contentType)) body = {
+			kind: "text",
+			value: await response.text()
+		};
+		else body = {
+			kind: "arrayBuffer",
+			value: await response.arrayBuffer()
+		};
+	}
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers,
+		body
+	};
+};
+const setupIpcBridge = (ipcMain, fetch, channel) => {
+	ipcMain.handle(channel, async (_event, payload) => {
+		return toIpcResponse(await fetch(toRequest(payload, channel)), payload.method);
+	});
+	return () => {
+		ipcMain.removeHandler(channel);
+	};
+};
+//#endregion
+//#region src/main/on-electron.ts
+const DEFAULT_IPC_CHANNEL = "http://zelt-ipc";
+const onElectron = async (app, options = {}) => {
+	const readyApp = await app.createRuntime({
+		fallbackConfigs: [ElectronEnvAdaptor],
+		warmup: options.warmup ?? true
+	});
+	const electronApp = await readyApp.get(ElectronAdaptor);
+	const channel = options.ipcChannel ?? DEFAULT_IPC_CHANNEL;
+	const removeIpcHandler = setupIpcBridge(electronApp.ready.ipcMain, readyApp.http.fetch, channel);
+	return {
+		get: readyApp.get,
+		fetch: readyApp.http.fetch,
+		shutdown: async () => {
+			removeIpcHandler();
+			await readyApp.shutdown();
+		}
+	};
+};
+//#endregion
+Object.defineProperty(exports, "ElectronAdaptor", {
+	enumerable: true,
+	get: function() {
+		return ElectronAdaptor;
+	}
+});
+Object.defineProperty(exports, "ElectronEnvAdaptor", {
+	enumerable: true,
+	get: function() {
+		return ElectronEnvAdaptor;
+	}
+});
+Object.defineProperty(exports, "ElectronWindowRegistryService", {
+	enumerable: true,
+	get: function() {
+		return ElectronWindowRegistryService;
+	}
+});
+Object.defineProperty(exports, "ElectronWindowRuntimeService", {
+	enumerable: true,
+	get: function() {
+		return ElectronWindowRuntimeService;
+	}
+});
+exports.onElectron = onElectron;
+exports.setupIpcBridge = setupIpcBridge;
+exports.toIpcResponse = toIpcResponse;
+exports.toRequest = toRequest;

package/dist/main/index.d.cts

@@ -0,0 +1,122 @@
+import { n as IpcFetchResponse, t as IpcFetchRequest } from "../ipc.types-DgxeccV3.cjs";
+import { ConfiguredFeature, CreateRuntimeOptions, EnvAdaptor, HttpCapabilities, Lifecycle, LifecycleManager, ReadyValue, RuntimeApp } from "@zeltjs/core";
+import { App, BrowserWindow, BrowserWindowConstructorOptions, Dialog, IpcMain, Menu, Protocol, Rectangle, Screen, Shell, WebContents } from "electron";
+
+//#region src/main/electron.adaptor.d.ts
+type ElectronReady = {
+  readonly app: App;
+  readonly ipcMain: IpcMain;
+  readonly protocol: Protocol;
+  readonly shell: Shell;
+  readonly screen: Screen;
+  readonly dialog: Dialog;
+  readonly Menu: typeof Menu;
+  readonly createBrowserWindow: (options: BrowserWindowConstructorOptions) => BrowserWindow;
+  readonly getAllWindows: () => BrowserWindow[];
+  readonly fromWebContents: (webContents: WebContents) => BrowserWindow | null;
+  readonly fromId: (id: number) => BrowserWindow | null;
+  readonly getFocusedWindow: () => BrowserWindow | null;
+};
+declare class ElectronAdaptor implements Lifecycle<ElectronReady> {
+  readonly ready: ReadyValue<ElectronReady>;
+  constructor(lifecycleManager?: LifecycleManager);
+  startup(): Promise<ElectronReady>;
+  shutdown(): void;
+}
+//#endregion
+//#region src/main/electron-env.adaptor.d.ts
+declare class ElectronEnvAdaptor extends EnvAdaptor {
+  get(key: string): string | undefined;
+}
+//#endregion
+//#region src/main/window.types.d.ts
+type WindowId = string;
+type WindowOpenHandlerResult = {
+  readonly action: 'allow' | 'deny';
+};
+type WindowHandle = {
+  readonly id: number;
+  readonly native: BrowserWindow;
+  close(): void;
+  focus(): void;
+  show(): void;
+  isDestroyed(): boolean;
+  getTitle(): string;
+  getBounds(): Rectangle;
+  setBounds(bounds: Partial<Rectangle>): void;
+  loadFile(path: string): void;
+  loadURL(url: string): void;
+  on(event: 'closed' | 'ready-to-show', handler: () => void): void;
+  removeListener(event: 'closed' | 'ready-to-show', handler: (...args: unknown[]) => void): void;
+  webContents: {
+    send(channel: string, ...args: unknown[]): void;
+    setWindowOpenHandler(handler: (details: {
+      url: string;
+    }) => WindowOpenHandlerResult): void;
+  };
+};
+type WindowLoadTarget = {
+  type: 'file';
+  readonly path: string;
+} | {
+  type: 'url';
+  readonly url: string;
+};
+type WindowDefinition = {
+  readonly id: WindowId;
+  readonly options: BrowserWindowConstructorOptions;
+  readonly loadTarget: WindowLoadTarget;
+};
+type WindowRuntime = {
+  open(definition: WindowDefinition): WindowHandle;
+};
+//#endregion
+//#region src/main/electron-window-runtime.service.d.ts
+declare class ElectronWindowRuntimeService implements WindowRuntime {
+  private readonly electronApp;
+  constructor(electronApp?: ElectronAdaptor);
+  open(definition: WindowDefinition): WindowHandle;
+  createWindowHandle(win: BrowserWindow): WindowHandle;
+}
+//#endregion
+//#region src/main/electron-window-registry.service.d.ts
+declare class ElectronWindowRegistryService {
+  private readonly runtime;
+  private readonly windows;
+  constructor(runtime?: ElectronWindowRuntimeService);
+  open(definition: WindowDefinition): WindowHandle;
+  close(id: WindowId): void;
+  closeAll(): void;
+  count(): number;
+}
+//#endregion
+//#region src/main/ipc-bridge.d.ts
+declare const toRequest: (payload: IpcFetchRequest, baseUrl: string) => Request;
+declare const toIpcResponse: (response: Response, method: string) => Promise<IpcFetchResponse>;
+type IpcMainLike = {
+  handle(channel: string, listener: (event: unknown, payload: IpcFetchRequest) => unknown): void;
+  removeHandler(channel: string): void;
+};
+declare const setupIpcBridge: (ipcMain: IpcMainLike, fetch: (request: Request) => Promise<Response>, channel: string) => (() => void);
+//#endregion
+//#region src/main/on-electron.d.ts
+type IpcChannel = `http://${string}` | `https://${string}`;
+type ElectronAppOptions = {
+  readonly warmup?: boolean;
+  readonly ipcChannel?: IpcChannel;
+};
+type HttpRuntimeApp = RuntimeApp<readonly ConfiguredFeature[]> & {
+  readonly http: HttpCapabilities;
+};
+type HttpApp = {
+  readonly createRuntime: (options?: CreateRuntimeOptions) => Promise<HttpRuntimeApp>;
+};
+type OnElectronApp = {
+  readonly get: HttpRuntimeApp['get'];
+  readonly fetch: (request: Request) => Promise<Response>;
+  readonly shutdown: () => Promise<void>;
+};
+declare const onElectron: (app: HttpApp, options?: ElectronAppOptions) => Promise<OnElectronApp>;
+//#endregion
+export { ElectronAdaptor, type ElectronAppOptions, ElectronEnvAdaptor, type ElectronReady, ElectronWindowRegistryService, ElectronWindowRuntimeService, type OnElectronApp, type WindowDefinition, type WindowHandle, type WindowId, type WindowLoadTarget, type WindowOpenHandlerResult, type WindowRuntime, onElectron, setupIpcBridge, toIpcResponse, toRequest };
+//# sourceMappingURL=index.d.cts.map

package/dist/main/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/main/electron.adaptor.ts","../../src/main/electron-env.adaptor.ts","../../src/main/window.types.ts","../../src/main/electron-window-runtime.service.ts","../../src/main/electron-window-registry.service.ts","../../src/main/ipc-bridge.ts","../../src/main/on-electron.ts"],"mappings":"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"}

package/dist/main/index.d.ts

@@ -0,0 +1,122 @@
+import { n as IpcFetchResponse, t as IpcFetchRequest } from "../ipc.types-OYZhXKH2.js";
+import { ConfiguredFeature, CreateRuntimeOptions, EnvAdaptor, HttpCapabilities, Lifecycle, LifecycleManager, ReadyValue, RuntimeApp } from "@zeltjs/core";
+import { App, BrowserWindow, BrowserWindowConstructorOptions, Dialog, IpcMain, Menu, Protocol, Rectangle, Screen, Shell, WebContents } from "electron";
+
+//#region src/main/electron.adaptor.d.ts
+type ElectronReady = {
+  readonly app: App;
+  readonly ipcMain: IpcMain;
+  readonly protocol: Protocol;
+  readonly shell: Shell;
+  readonly screen: Screen;
+  readonly dialog: Dialog;
+  readonly Menu: typeof Menu;
+  readonly createBrowserWindow: (options: BrowserWindowConstructorOptions) => BrowserWindow;
+  readonly getAllWindows: () => BrowserWindow[];
+  readonly fromWebContents: (webContents: WebContents) => BrowserWindow | null;
+  readonly fromId: (id: number) => BrowserWindow | null;
+  readonly getFocusedWindow: () => BrowserWindow | null;
+};
+declare class ElectronAdaptor implements Lifecycle<ElectronReady> {
+  readonly ready: ReadyValue<ElectronReady>;
+  constructor(lifecycleManager?: LifecycleManager);
+  startup(): Promise<ElectronReady>;
+  shutdown(): void;
+}
+//#endregion
+//#region src/main/electron-env.adaptor.d.ts
+declare class ElectronEnvAdaptor extends EnvAdaptor {
+  get(key: string): string | undefined;
+}
+//#endregion
+//#region src/main/window.types.d.ts
+type WindowId = string;
+type WindowOpenHandlerResult = {
+  readonly action: 'allow' | 'deny';
+};
+type WindowHandle = {
+  readonly id: number;
+  readonly native: BrowserWindow;
+  close(): void;
+  focus(): void;
+  show(): void;
+  isDestroyed(): boolean;
+  getTitle(): string;
+  getBounds(): Rectangle;
+  setBounds(bounds: Partial<Rectangle>): void;
+  loadFile(path: string): void;
+  loadURL(url: string): void;
+  on(event: 'closed' | 'ready-to-show', handler: () => void): void;
+  removeListener(event: 'closed' | 'ready-to-show', handler: (...args: unknown[]) => void): void;
+  webContents: {
+    send(channel: string, ...args: unknown[]): void;
+    setWindowOpenHandler(handler: (details: {
+      url: string;
+    }) => WindowOpenHandlerResult): void;
+  };
+};
+type WindowLoadTarget = {
+  type: 'file';
+  readonly path: string;
+} | {
+  type: 'url';
+  readonly url: string;
+};
+type WindowDefinition = {
+  readonly id: WindowId;
+  readonly options: BrowserWindowConstructorOptions;
+  readonly loadTarget: WindowLoadTarget;
+};
+type WindowRuntime = {
+  open(definition: WindowDefinition): WindowHandle;
+};
+//#endregion
+//#region src/main/electron-window-runtime.service.d.ts
+declare class ElectronWindowRuntimeService implements WindowRuntime {
+  private readonly electronApp;
+  constructor(electronApp?: ElectronAdaptor);
+  open(definition: WindowDefinition): WindowHandle;
+  createWindowHandle(win: BrowserWindow): WindowHandle;
+}
+//#endregion
+//#region src/main/electron-window-registry.service.d.ts
+declare class ElectronWindowRegistryService {
+  private readonly runtime;
+  private readonly windows;
+  constructor(runtime?: ElectronWindowRuntimeService);
+  open(definition: WindowDefinition): WindowHandle;
+  close(id: WindowId): void;
+  closeAll(): void;
+  count(): number;
+}
+//#endregion
+//#region src/main/ipc-bridge.d.ts
+declare const toRequest: (payload: IpcFetchRequest, baseUrl: string) => Request;
+declare const toIpcResponse: (response: Response, method: string) => Promise<IpcFetchResponse>;
+type IpcMainLike = {
+  handle(channel: string, listener: (event: unknown, payload: IpcFetchRequest) => unknown): void;
+  removeHandler(channel: string): void;
+};
+declare const setupIpcBridge: (ipcMain: IpcMainLike, fetch: (request: Request) => Promise<Response>, channel: string) => (() => void);
+//#endregion
+//#region src/main/on-electron.d.ts
+type IpcChannel = `http://${string}` | `https://${string}`;
+type ElectronAppOptions = {
+  readonly warmup?: boolean;
+  readonly ipcChannel?: IpcChannel;
+};
+type HttpRuntimeApp = RuntimeApp<readonly ConfiguredFeature[]> & {
+  readonly http: HttpCapabilities;
+};
+type HttpApp = {
+  readonly createRuntime: (options?: CreateRuntimeOptions) => Promise<HttpRuntimeApp>;
+};
+type OnElectronApp = {
+  readonly get: HttpRuntimeApp['get'];
+  readonly fetch: (request: Request) => Promise<Response>;
+  readonly shutdown: () => Promise<void>;
+};
+declare const onElectron: (app: HttpApp, options?: ElectronAppOptions) => Promise<OnElectronApp>;
+//#endregion
+export { ElectronAdaptor, type ElectronAppOptions, ElectronEnvAdaptor, type ElectronReady, ElectronWindowRegistryService, ElectronWindowRuntimeService, type OnElectronApp, type WindowDefinition, type WindowHandle, type WindowId, type WindowLoadTarget, type WindowOpenHandlerResult, type WindowRuntime, onElectron, setupIpcBridge, toIpcResponse, toRequest };
+//# sourceMappingURL=index.d.ts.map

package/dist/main/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/main/electron.adaptor.ts","../../src/main/electron-env.adaptor.ts","../../src/main/window.types.ts","../../src/main/electron-window-runtime.service.ts","../../src/main/electron-window-registry.service.ts","../../src/main/ipc-bridge.ts","../../src/main/on-electron.ts"],"mappings":"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"}

package/dist/main/index.js

@@ -0,0 +1,240 @@
+import { Config, EnvAdaptor, Injectable, LifecycleManager, inject } from "@zeltjs/core";
+import { match } from "ts-pattern";
+//#region src/main/electron.adaptor.ts
+function _ts_decorate$3(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;
+}
+function _ts_metadata$2(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var ElectronAdaptor = class {
+	async startup() {
+		const { app, BrowserWindow: BW, dialog, ipcMain, Menu, protocol, screen, shell } = await import("electron");
+		await app.whenReady();
+		return {
+			app,
+			ipcMain,
+			protocol,
+			shell,
+			screen,
+			dialog,
+			Menu,
+			createBrowserWindow: (options) => new BW(options),
+			getAllWindows: () => BW.getAllWindows(),
+			fromWebContents: (wc) => BW.fromWebContents(wc),
+			fromId: (id) => BW.fromId(id),
+			getFocusedWindow: () => BW.getFocusedWindow()
+		};
+	}
+	shutdown() {
+		this.ready.app.quit();
+	}
+	constructor(lifecycleManager = inject(LifecycleManager)) {
+		this.ready = lifecycleManager.register(this);
+	}
+};
+ElectronAdaptor = _ts_decorate$3([
+	Injectable(),
+	_ts_metadata$2("design:type", Function),
+	_ts_metadata$2("design:paramtypes", [void 0])
+], ElectronAdaptor);
+//#endregion
+//#region src/main/electron-env.adaptor.ts
+function _ts_decorate$2(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 ElectronEnvAdaptor = class extends EnvAdaptor {
+	get(key) {
+		return process.env[key];
+	}
+};
+ElectronEnvAdaptor = _ts_decorate$2([Config], ElectronEnvAdaptor);
+//#endregion
+//#region src/main/electron-window-runtime.service.ts
+function _ts_decorate$1(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;
+}
+function _ts_metadata$1(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var ElectronWindowRuntimeService = class {
+	open(definition) {
+		const handle = this.createWindowHandle(this.electronApp.ready.createBrowserWindow(definition.options));
+		if (definition.loadTarget.type === "url") handle.loadURL(definition.loadTarget.url);
+		else handle.loadFile(definition.loadTarget.path);
+		return handle;
+	}
+	createWindowHandle(win) {
+		return {
+			id: win.id,
+			native: win,
+			close: () => win.close(),
+			focus: () => win.focus(),
+			show: () => win.show(),
+			isDestroyed: () => win.isDestroyed(),
+			getTitle: () => win.getTitle(),
+			getBounds: () => win.getBounds(),
+			setBounds: (bounds) => win.setBounds(bounds),
+			loadFile: (path) => {
+				win.loadFile(path);
+			},
+			loadURL: (url) => {
+				win.loadURL(url);
+			},
+			on: (event, handler) => {
+				match(event).with("closed", (e) => win.on(e, handler)).with("ready-to-show", (e) => win.on(e, handler)).exhaustive();
+			},
+			removeListener: (event, handler) => {
+				match(event).with("closed", (e) => win.removeListener(e, handler)).with("ready-to-show", (e) => win.removeListener(e, handler)).exhaustive();
+			},
+			webContents: {
+				send: (channel, ...args) => win.webContents.send(channel, ...args),
+				setWindowOpenHandler: (handler) => win.webContents.setWindowOpenHandler(handler)
+			}
+		};
+	}
+	constructor(electronApp = inject(ElectronAdaptor)) {
+		this.electronApp = electronApp;
+	}
+};
+ElectronWindowRuntimeService = _ts_decorate$1([
+	Injectable(),
+	_ts_metadata$1("design:type", Function),
+	_ts_metadata$1("design:paramtypes", [typeof ElectronAdaptor === "undefined" ? Object : ElectronAdaptor])
+], ElectronWindowRuntimeService);
+//#endregion
+//#region src/main/electron-window-registry.service.ts
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var ElectronWindowRegistryService = class {
+	open(definition) {
+		const existing = this.windows.get(definition.id);
+		if (existing && !existing.isDestroyed()) {
+			existing.focus();
+			return existing;
+		}
+		const handle = this.runtime.open(definition);
+		this.windows.set(definition.id, handle);
+		handle.on("closed", () => {
+			this.windows.delete(definition.id);
+		});
+		return handle;
+	}
+	close(id) {
+		const handle = this.windows.get(id);
+		if (handle && !handle.isDestroyed()) handle.close();
+	}
+	closeAll() {
+		for (const handle of this.windows.values()) if (!handle.isDestroyed()) handle.close();
+	}
+	count() {
+		return this.windows.size;
+	}
+	constructor(runtime = inject(ElectronWindowRuntimeService)) {
+		this.runtime = runtime;
+		this.windows = /* @__PURE__ */ new Map();
+	}
+};
+ElectronWindowRegistryService = _ts_decorate([
+	Injectable(),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [void 0])
+], ElectronWindowRegistryService);
+//#endregion
+//#region src/main/ipc-bridge.ts
+const BODY_FORBIDDEN_METHODS = new Set(["GET", "HEAD"]);
+const NO_BODY_STATUSES = new Set([
+	204,
+	205,
+	304
+]);
+const TEXT_CONTENT_TYPE_PREFIXES = [
+	"text/",
+	"application/json",
+	"application/xml",
+	"application/javascript",
+	"application/x-www-form-urlencoded"
+];
+const isTextContentType = (contentType) => TEXT_CONTENT_TYPE_PREFIXES.some((prefix) => contentType.startsWith(prefix));
+const toBody = (body) => match(body).with({ kind: "none" }, () => null).with({ kind: "text" }, ({ value }) => value).with({ kind: "arrayBuffer" }, ({ value }) => value).exhaustive();
+const toRequest = (payload, baseUrl) => {
+	const headers = payload.headers.map(([k, v]) => [k, v]);
+	return new Request(baseUrl + payload.path, {
+		method: payload.method,
+		headers,
+		body: BODY_FORBIDDEN_METHODS.has(payload.method) ? null : toBody(payload.body)
+	});
+};
+const toIpcResponse = async (response, method) => {
+	const headers = [];
+	response.headers.forEach((value, key) => {
+		headers.push([key, value]);
+	});
+	let body;
+	if (NO_BODY_STATUSES.has(response.status) || method === "HEAD") body = { kind: "none" };
+	else {
+		const contentType = response.headers.get("content-type");
+		if (contentType && isTextContentType(contentType)) body = {
+			kind: "text",
+			value: await response.text()
+		};
+		else body = {
+			kind: "arrayBuffer",
+			value: await response.arrayBuffer()
+		};
+	}
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers,
+		body
+	};
+};
+const setupIpcBridge = (ipcMain, fetch, channel) => {
+	ipcMain.handle(channel, async (_event, payload) => {
+		return toIpcResponse(await fetch(toRequest(payload, channel)), payload.method);
+	});
+	return () => {
+		ipcMain.removeHandler(channel);
+	};
+};
+//#endregion
+//#region src/main/on-electron.ts
+const DEFAULT_IPC_CHANNEL = "http://zelt-ipc";
+const onElectron = async (app, options = {}) => {
+	const readyApp = await app.createRuntime({
+		fallbackConfigs: [ElectronEnvAdaptor],
+		warmup: options.warmup ?? true
+	});
+	const electronApp = await readyApp.get(ElectronAdaptor);
+	const channel = options.ipcChannel ?? DEFAULT_IPC_CHANNEL;
+	const removeIpcHandler = setupIpcBridge(electronApp.ready.ipcMain, readyApp.http.fetch, channel);
+	return {
+		get: readyApp.get,
+		fetch: readyApp.http.fetch,
+		shutdown: async () => {
+			removeIpcHandler();
+			await readyApp.shutdown();
+		}
+	};
+};
+//#endregion
+export { ElectronAdaptor, ElectronEnvAdaptor, ElectronWindowRegistryService, ElectronWindowRuntimeService, onElectron, setupIpcBridge, toIpcResponse, toRequest };
+
+//# sourceMappingURL=index.js.map

package/dist/main/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["Injectable","inject","LifecycleManager","ElectronAdaptor","startup","app","BrowserWindow","BW","dialog","ipcMain","Menu","protocol","screen","shell","whenReady","createBrowserWindow","options","getAllWindows","fromWebContents","wc","fromId","id","getFocusedWindow","shutdown","ready","quit","lifecycleManager","register","Config","EnvAdaptor","ElectronEnvAdaptor","get","key","process","env","Injectable","inject","match","ElectronAdaptor","ElectronWindowRuntimeService","open","definition","handle","createWindowHandle","electronApp","ready","createBrowserWindow","options","loadTarget","type","loadURL","url","loadFile","path","win","id","native","close","focus","show","isDestroyed","getTitle","getBounds","setBounds","bounds","on","event","handler","with","e","exhaustive","removeListener","webContents","send","channel","args","setWindowOpenHandler","Injectable","inject","ElectronWindowRuntimeService","ElectronWindowRegistryService","open","definition","existing","windows","get","id","isDestroyed","focus","handle","runtime","set","on","delete","close","closeAll","values","count","size","Map","match","BODY_FORBIDDEN_METHODS","Set","NO_BODY_STATUSES","TEXT_CONTENT_TYPE_PREFIXES","isTextContentType","contentType","some","prefix","startsWith","toBody","body","with","kind","value","exhaustive","toRequest","payload","baseUrl","headers","map","k","v","Request","path","method","has","toIpcResponse","response","forEach","key","push","status","get","text","arrayBuffer","statusText","setupIpcBridge","ipcMain","fetch","channel","handle","_event","request","removeHandler","ElectronAdaptor","ElectronEnvAdaptor","setupIpcBridge","DEFAULT_IPC_CHANNEL","onElectron","app","options","readyApp","createRuntime","fallbackConfigs","warmup","electronApp","get","channel","ipcChannel","removeIpcHandler","ready","ipcMain","http","fetch","shutdown"],"sources":["../../src/main/electron.adaptor.ts","../../src/main/electron-env.adaptor.ts","../../src/main/electron-window-runtime.service.ts","../../src/main/electron-window-registry.service.ts","../../src/main/ipc-bridge.ts","../../src/main/on-electron.ts"],"sourcesContent":["import type { Lifecycle, ReadyValue } from '@zeltjs/core';\nimport { Injectable, inject, LifecycleManager } from '@zeltjs/core';\nimport type {\n  App,\n  BrowserWindow,\n  BrowserWindowConstructorOptions,\n  Dialog,\n  IpcMain,\n  Menu,\n  Protocol,\n  Screen,\n  Shell,\n  WebContents,\n} from 'electron';\n\nexport type ElectronReady = {\n  readonly app: App;\n  readonly ipcMain: IpcMain;\n  readonly protocol: Protocol;\n  readonly shell: Shell;\n  readonly screen: Screen;\n  readonly dialog: Dialog;\n  readonly Menu: typeof Menu;\n  readonly createBrowserWindow: (options: BrowserWindowConstructorOptions) => BrowserWindow;\n  readonly getAllWindows: () => BrowserWindow[];\n  readonly fromWebContents: (webContents: WebContents) => BrowserWindow | null;\n  readonly fromId: (id: number) => BrowserWindow | null;\n  readonly getFocusedWindow: () => BrowserWindow | null;\n};\n\n@Injectable()\nexport class ElectronAdaptor implements Lifecycle<ElectronReady> {\n  readonly ready: ReadyValue<ElectronReady>;\n\n  constructor(lifecycleManager = inject(LifecycleManager)) {\n    this.ready = lifecycleManager.register(this);\n  }\n\n  async startup(): Promise<ElectronReady> {\n    const {\n      app,\n      BrowserWindow: BW,\n      dialog,\n      ipcMain,\n      Menu,\n      protocol,\n      screen,\n      shell,\n    } = await import('electron');\n\n    await app.whenReady();\n\n    return {\n      app,\n      ipcMain,\n      protocol,\n      shell,\n      screen,\n      dialog,\n      Menu,\n      createBrowserWindow: (options: BrowserWindowConstructorOptions) => new BW(options),\n      getAllWindows: () => BW.getAllWindows(),\n      fromWebContents: (wc: WebContents) => BW.fromWebContents(wc),\n      fromId: (id: number) => BW.fromId(id),\n      getFocusedWindow: () => BW.getFocusedWindow(),\n    };\n  }\n\n  shutdown(): void {\n    this.ready.app.quit();\n  }\n}\n","import { Config, EnvAdaptor } from '@zeltjs/core';\n\n@Config\nexport class ElectronEnvAdaptor extends EnvAdaptor {\n  override get(key: string): string | undefined {\n    return process.env[key];\n  }\n}\n","import { Injectable, inject } from '@zeltjs/core';\nimport type { BrowserWindow } from 'electron';\nimport { match } from 'ts-pattern';\nimport { ElectronAdaptor } from './electron.adaptor';\nimport type { WindowDefinition, WindowHandle, WindowRuntime } from './window.types';\n\n@Injectable()\nexport class ElectronWindowRuntimeService implements WindowRuntime {\n  constructor(private readonly electronApp: ElectronAdaptor = inject(ElectronAdaptor)) {}\n\n  open(definition: WindowDefinition): WindowHandle {\n    const handle = this.createWindowHandle(\n      this.electronApp.ready.createBrowserWindow(definition.options),\n    );\n\n    if (definition.loadTarget.type === 'url') {\n      handle.loadURL(definition.loadTarget.url);\n    } else {\n      handle.loadFile(definition.loadTarget.path);\n    }\n\n    return handle;\n  }\n\n  createWindowHandle(win: BrowserWindow): WindowHandle {\n    return {\n      id: win.id,\n      native: win,\n      close: () => win.close(),\n      focus: () => win.focus(),\n      show: () => win.show(),\n      isDestroyed: () => win.isDestroyed(),\n      getTitle: () => win.getTitle(),\n      getBounds: () => win.getBounds(),\n      setBounds: (bounds) => win.setBounds(bounds),\n      loadFile: (path) => {\n        void win.loadFile(path);\n      },\n      loadURL: (url) => {\n        void win.loadURL(url);\n      },\n      on: (event, handler) => {\n        match(event)\n          .with('closed', (e) => win.on(e, handler))\n          .with('ready-to-show', (e) => win.on(e, handler))\n          .exhaustive();\n      },\n      removeListener: (event, handler) => {\n        match(event)\n          .with('closed', (e) => win.removeListener(e, handler))\n          .with('ready-to-show', (e) => win.removeListener(e, handler))\n          .exhaustive();\n      },\n      webContents: {\n        send: (channel, ...args) => win.webContents.send(channel, ...args),\n        setWindowOpenHandler: (handler) => win.webContents.setWindowOpenHandler(handler),\n      },\n    };\n  }\n}\n","import { Injectable, inject } from '@zeltjs/core';\nimport { ElectronWindowRuntimeService } from './electron-window-runtime.service';\nimport type { WindowDefinition, WindowHandle, WindowId } from './window.types';\n\n@Injectable()\nexport class ElectronWindowRegistryService {\n  private readonly windows = new Map<WindowId, WindowHandle>();\n\n  constructor(private readonly runtime = inject(ElectronWindowRuntimeService)) {}\n\n  open(definition: WindowDefinition): WindowHandle {\n    const existing = this.windows.get(definition.id);\n    if (existing && !existing.isDestroyed()) {\n      existing.focus();\n      return existing;\n    }\n\n    const handle = this.runtime.open(definition);\n    this.windows.set(definition.id, handle);\n\n    handle.on('closed', () => {\n      this.windows.delete(definition.id);\n    });\n\n    return handle;\n  }\n\n  close(id: WindowId): void {\n    const handle = this.windows.get(id);\n    if (handle && !handle.isDestroyed()) {\n      handle.close();\n    }\n  }\n\n  closeAll(): void {\n    for (const handle of this.windows.values()) {\n      if (!handle.isDestroyed()) {\n        handle.close();\n      }\n    }\n  }\n\n  count(): number {\n    return this.windows.size;\n  }\n}\n","import { match } from 'ts-pattern';\n\nimport type { IpcBody, IpcFetchRequest, IpcFetchResponse } from '../shared/ipc.types';\n\nconst BODY_FORBIDDEN_METHODS = new Set(['GET', 'HEAD']);\nconst NO_BODY_STATUSES = new Set([204, 205, 304]);\nconst TEXT_CONTENT_TYPE_PREFIXES = [\n  'text/',\n  'application/json',\n  'application/xml',\n  'application/javascript',\n  'application/x-www-form-urlencoded',\n];\n\nconst isTextContentType = (contentType: string): boolean =>\n  TEXT_CONTENT_TYPE_PREFIXES.some((prefix) => contentType.startsWith(prefix));\n\nconst toBody = (body: IpcBody): BodyInit | null =>\n  match(body)\n    .with({ kind: 'none' }, () => null)\n    .with({ kind: 'text' }, ({ value }) => value)\n    .with({ kind: 'arrayBuffer' }, ({ value }) => value)\n    .exhaustive();\n\nexport const toRequest = (payload: IpcFetchRequest, baseUrl: string): Request => {\n  const headers: [string, string][] = payload.headers.map(([k, v]) => [k, v]);\n  return new Request(baseUrl + payload.path, {\n    method: payload.method,\n    headers,\n    body: BODY_FORBIDDEN_METHODS.has(payload.method) ? null : toBody(payload.body),\n  });\n};\n\nexport const toIpcResponse = async (\n  response: Response,\n  method: string,\n): Promise<IpcFetchResponse> => {\n  const headers: [string, string][] = [];\n  response.headers.forEach((value, key) => {\n    headers.push([key, value]);\n  });\n\n  let body: IpcBody;\n  if (NO_BODY_STATUSES.has(response.status) || method === 'HEAD') {\n    body = { kind: 'none' };\n  } else {\n    const contentType = response.headers.get('content-type');\n    if (contentType && isTextContentType(contentType)) {\n      body = { kind: 'text', value: await response.text() };\n    } else {\n      body = { kind: 'arrayBuffer', value: await response.arrayBuffer() };\n    }\n  }\n\n  return {\n    status: response.status,\n    statusText: response.statusText,\n    headers,\n    body,\n  };\n};\n\ntype IpcMainLike = {\n  handle(channel: string, listener: (event: unknown, payload: IpcFetchRequest) => unknown): void;\n  removeHandler(channel: string): void;\n};\n\nexport const setupIpcBridge = (\n  ipcMain: IpcMainLike,\n  fetch: (request: Request) => Promise<Response>,\n  channel: string,\n): (() => void) => {\n  ipcMain.handle(channel, async (_event: unknown, payload: IpcFetchRequest) => {\n    const request = toRequest(payload, channel);\n    const response = await fetch(request);\n    return toIpcResponse(response, payload.method);\n  });\n\n  return () => {\n    ipcMain.removeHandler(channel);\n  };\n};\n","import type {\n  ConfiguredFeature,\n  CreateRuntimeOptions,\n  HttpCapabilities,\n  RuntimeApp,\n} from '@zeltjs/core';\nimport { ElectronAdaptor } from './electron.adaptor';\nimport { ElectronEnvAdaptor } from './electron-env.adaptor';\nimport { setupIpcBridge } from './ipc-bridge';\n\ntype IpcChannel = `http://${string}` | `https://${string}`;\n\nexport type ElectronAppOptions = {\n  readonly warmup?: boolean;\n  readonly ipcChannel?: IpcChannel;\n};\n\ntype HttpRuntimeApp = RuntimeApp<readonly ConfiguredFeature[]> & {\n  readonly http: HttpCapabilities;\n};\n\ntype HttpApp = {\n  readonly createRuntime: (options?: CreateRuntimeOptions) => Promise<HttpRuntimeApp>;\n};\n\nexport type OnElectronApp = {\n  readonly get: HttpRuntimeApp['get'];\n  readonly fetch: (request: Request) => Promise<Response>;\n  readonly shutdown: () => Promise<void>;\n};\n\nconst DEFAULT_IPC_CHANNEL = 'http://zelt-ipc';\n\nexport const onElectron = async (\n  app: HttpApp,\n  options: ElectronAppOptions = {},\n): Promise<OnElectronApp> => {\n  const readyApp = await app.createRuntime({\n    fallbackConfigs: [ElectronEnvAdaptor],\n    warmup: options.warmup ?? true,\n  });\n\n  const electronApp = await readyApp.get(ElectronAdaptor);\n  const channel = options.ipcChannel ?? DEFAULT_IPC_CHANNEL;\n\n  const removeIpcHandler = setupIpcBridge(electronApp.ready.ipcMain, readyApp.http.fetch, channel);\n\n  return {\n    get: readyApp.get,\n    fetch: readyApp.http.fetch,\n    shutdown: async () => {\n      removeIpcHandler();\n      await readyApp.shutdown();\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/preload/index.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/preload/expose-ipc.ts
+const DEFAULT_IPC_CHANNEL = "http://zelt-ipc";
+const loadElectron = () => {
+	return require("electron");
+};
+const exposeIpc = (options = {}) => {
+	const channel = options.channel ?? DEFAULT_IPC_CHANNEL;
+	const { contextBridge, ipcRenderer } = loadElectron();
+	const sender = (request) => ipcRenderer.invoke(channel, request);
+	if (process.contextIsolated) contextBridge.exposeInMainWorld(channel, sender);
+	else Reflect.set(globalThis, channel, sender);
+};
+//#endregion
+exports.exposeIpc = exposeIpc;

package/dist/preload/index.d.cts

@@ -0,0 +1,10 @@
+import { n as IpcFetchResponse, r as IpcSender, t as IpcFetchRequest } from "../ipc.types-DgxeccV3.cjs";
+
+//#region src/preload/expose-ipc.d.ts
+type ExposeIpcOptions = {
+  readonly channel?: string;
+};
+declare const exposeIpc: (options?: ExposeIpcOptions) => void;
+//#endregion
+export { type ExposeIpcOptions, type IpcFetchRequest, type IpcFetchResponse, type IpcSender, exposeIpc };
+//# sourceMappingURL=index.d.cts.map

package/dist/preload/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/preload/expose-ipc.ts"],"mappings":";;;KAMY,gBAAA;EAAA,SACD,OAAA;AAAA;AAAA,cAcE,SAAA,GAAa,OAAA,GAAS,gBAAA"}

package/dist/preload/index.d.ts

@@ -0,0 +1,10 @@
+import { n as IpcFetchResponse, r as IpcSender, t as IpcFetchRequest } from "../ipc.types-OYZhXKH2.js";
+
+//#region src/preload/expose-ipc.d.ts
+type ExposeIpcOptions = {
+  readonly channel?: string;
+};
+declare const exposeIpc: (options?: ExposeIpcOptions) => void;
+//#endregion
+export { type ExposeIpcOptions, type IpcFetchRequest, type IpcFetchResponse, type IpcSender, exposeIpc };
+//# sourceMappingURL=index.d.ts.map

package/dist/preload/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/preload/expose-ipc.ts"],"mappings":";;;KAMY,gBAAA;EAAA,SACD,OAAA;AAAA;AAAA,cAcE,SAAA,GAAa,OAAA,GAAS,gBAAA"}

package/dist/preload/index.js

@@ -0,0 +1,20 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/preload/expose-ipc.ts
+const DEFAULT_IPC_CHANNEL = "http://zelt-ipc";
+const loadElectron = () => {
+	return __require("electron");
+};
+const exposeIpc = (options = {}) => {
+	const channel = options.channel ?? DEFAULT_IPC_CHANNEL;
+	const { contextBridge, ipcRenderer } = loadElectron();
+	const sender = (request) => ipcRenderer.invoke(channel, request);
+	if (process.contextIsolated) contextBridge.exposeInMainWorld(channel, sender);
+	else Reflect.set(globalThis, channel, sender);
+};
+//#endregion
+export { exposeIpc };
+
+//# sourceMappingURL=index.js.map

package/dist/preload/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["DEFAULT_IPC_CHANNEL","loadElectron","mod","require","exposeIpc","options","channel","contextBridge","ipcRenderer","sender","request","invoke","process","contextIsolated","exposeInMainWorld","Reflect","set","globalThis"],"sources":["../../src/preload/expose-ipc.ts"],"sourcesContent":["import type { ContextBridge, IpcRenderer } from 'electron';\n\nimport type { IpcFetchRequest, IpcFetchResponse } from '../shared/ipc.types';\n\nconst DEFAULT_IPC_CHANNEL = 'http://zelt-ipc';\n\nexport type ExposeIpcOptions = {\n  readonly channel?: string;\n};\n\ntype ElectronPreload = {\n  readonly contextBridge: ContextBridge;\n  readonly ipcRenderer: IpcRenderer;\n};\n\n// In the preload context electron is only available via require (no ESM in preload).\nconst loadElectron = (): ElectronPreload => {\n  const mod: ElectronPreload = require('electron');\n  return mod;\n};\n\nexport const exposeIpc = (options: ExposeIpcOptions = {}): void => {\n  const channel = options.channel ?? DEFAULT_IPC_CHANNEL;\n  const { contextBridge, ipcRenderer } = loadElectron();\n\n  const sender = (request: IpcFetchRequest): Promise<IpcFetchResponse> =>\n    ipcRenderer.invoke(channel, request);\n\n  if (process.contextIsolated) {\n    contextBridge.exposeInMainWorld(channel, sender);\n  } else {\n    Reflect.set(globalThis, channel, sender);\n  }\n};\n"],"mappings":";;;;;AAIA,MAAMA,sBAAsB;AAY5B,MAAMC,qBAAe;AAEnB,QAAA,UADqC,WAC9BC;;AAGT,MAAaE,aAAaC,UAA4B,EAAE,KAAA;CACtD,MAAMC,UAAUD,QAAQC,WAAWN;CACnC,MAAM,EAAEO,eAAeC,gBAAgBP,cAAAA;CAEvC,MAAMQ,UAAUC,YACdF,YAAYG,OAAOL,SAASI,QAAAA;AAE9B,KAAIE,QAAQC,gBACVN,eAAcO,kBAAkBR,SAASG,OAAAA;KAEzCM,SAAQC,IAAIC,YAAYX,SAASG,OAAAA"}

package/dist/renderer/index.cjs

@@ -0,0 +1,62 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/renderer/ipc-fetch.ts
+const TEXT_CONTENT_TYPE_PREFIXES = [
+	"text/",
+	"application/json",
+	"application/xml",
+	"application/javascript",
+	"application/x-www-form-urlencoded"
+];
+const isTextContentType = (contentType) => TEXT_CONTENT_TYPE_PREFIXES.some((prefix) => contentType.startsWith(prefix));
+const toIpcRequest = async (input, init) => {
+	const request = new Request(input, init);
+	const url = new URL(request.url);
+	const headers = [];
+	request.headers.forEach((value, key) => {
+		headers.push([key, value]);
+	});
+	let body;
+	if (request.body === null) body = { kind: "none" };
+	else {
+		const contentType = request.headers.get("content-type");
+		if (contentType && isTextContentType(contentType)) body = {
+			kind: "text",
+			value: await request.text()
+		};
+		else body = {
+			kind: "arrayBuffer",
+			value: await request.arrayBuffer()
+		};
+	}
+	return {
+		method: request.method,
+		path: url.pathname + url.search,
+		headers,
+		body
+	};
+};
+const toResponse = (payload) => {
+	let body = null;
+	if (payload.body.kind === "text") body = payload.body.value;
+	else if (payload.body.kind === "arrayBuffer") body = payload.body.value;
+	const headers = payload.headers.map(([k, v]) => [k, v]);
+	return new Response(body, {
+		status: payload.status,
+		statusText: payload.statusText,
+		headers
+	});
+};
+const DEFAULT_IPC_CHANNEL = "http://zelt-ipc";
+/**
+* @throws {Error} when the IPC sender is not registered for the given channel
+*/ const ipcFetch = async (input, init, options) => {
+	const channel = options?.channel ?? DEFAULT_IPC_CHANNEL;
+	const senderCandidate = Reflect.get(globalThis, channel);
+	if (typeof senderCandidate !== "function") throw new Error(`IPC sender not found for channel "${channel}". Did you call exposeIpc() in the preload script?`);
+	const ipcRequest = await toIpcRequest(input, init);
+	return toResponse(await senderCandidate.call(null, ipcRequest));
+};
+//#endregion
+exports.ipcFetch = ipcFetch;
+exports.toIpcRequest = toIpcRequest;
+exports.toResponse = toResponse;

package/dist/renderer/index.d.cts

@@ -0,0 +1,15 @@
+import { n as IpcFetchResponse, r as IpcSender, t as IpcFetchRequest } from "../ipc.types-DgxeccV3.cjs";
+
+//#region src/renderer/ipc-fetch.d.ts
+declare const toIpcRequest: (input: RequestInfo | URL, init?: RequestInit) => Promise<IpcFetchRequest>;
+declare const toResponse: (payload: IpcFetchResponse) => Response;
+type IpcFetchOptions = {
+  readonly channel?: string;
+};
+/**
+ * @throws {Error} when the IPC sender is not registered for the given channel
+ */
+declare const ipcFetch: (input: RequestInfo | URL, init?: RequestInit, options?: IpcFetchOptions) => Promise<Response>;
+//#endregion
+export { type IpcFetchOptions, type IpcFetchRequest, type IpcFetchResponse, type IpcSender, ipcFetch, toIpcRequest, toResponse };
+//# sourceMappingURL=index.d.cts.map

package/dist/renderer/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/renderer/ipc-fetch.ts"],"mappings":";;;cAaa,YAAA,GACX,KAAA,EAAO,WAAA,GAAc,GAAA,EACrB,IAAA,GAAO,WAAA,KACN,OAAA,CAAQ,eAAA;AAAA,cA6BE,UAAA,GAAc,OAAA,EAAS,gBAAA,KAAmB,QAAA;AAAA,KAkB3C,eAAA;EAAA,SACD,OAAA;AAAA;;;;cAME,QAAA,GACX,KAAA,EAAO,WAAA,GAAc,GAAA,EACrB,IAAA,GAAO,WAAA,EACP,OAAA,GAAU,eAAA,KACT,OAAA,CAAQ,QAAA"}

package/dist/renderer/index.d.ts

@@ -0,0 +1,15 @@
+import { n as IpcFetchResponse, r as IpcSender, t as IpcFetchRequest } from "../ipc.types-OYZhXKH2.js";
+
+//#region src/renderer/ipc-fetch.d.ts
+declare const toIpcRequest: (input: RequestInfo | URL, init?: RequestInit) => Promise<IpcFetchRequest>;
+declare const toResponse: (payload: IpcFetchResponse) => Response;
+type IpcFetchOptions = {
+  readonly channel?: string;
+};
+/**
+ * @throws {Error} when the IPC sender is not registered for the given channel
+ */
+declare const ipcFetch: (input: RequestInfo | URL, init?: RequestInit, options?: IpcFetchOptions) => Promise<Response>;
+//#endregion
+export { type IpcFetchOptions, type IpcFetchRequest, type IpcFetchResponse, type IpcSender, ipcFetch, toIpcRequest, toResponse };
+//# sourceMappingURL=index.d.ts.map

package/dist/renderer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/renderer/ipc-fetch.ts"],"mappings":";;;cAaa,YAAA,GACX,KAAA,EAAO,WAAA,GAAc,GAAA,EACrB,IAAA,GAAO,WAAA,KACN,OAAA,CAAQ,eAAA;AAAA,cA6BE,UAAA,GAAc,OAAA,EAAS,gBAAA,KAAmB,QAAA;AAAA,KAkB3C,eAAA;EAAA,SACD,OAAA;AAAA;;;;cAME,QAAA,GACX,KAAA,EAAO,WAAA,GAAc,GAAA,EACrB,IAAA,GAAO,WAAA,EACP,OAAA,GAAU,eAAA,KACT,OAAA,CAAQ,QAAA"}

package/dist/renderer/index.js

@@ -0,0 +1,61 @@
+//#region src/renderer/ipc-fetch.ts
+const TEXT_CONTENT_TYPE_PREFIXES = [
+	"text/",
+	"application/json",
+	"application/xml",
+	"application/javascript",
+	"application/x-www-form-urlencoded"
+];
+const isTextContentType = (contentType) => TEXT_CONTENT_TYPE_PREFIXES.some((prefix) => contentType.startsWith(prefix));
+const toIpcRequest = async (input, init) => {
+	const request = new Request(input, init);
+	const url = new URL(request.url);
+	const headers = [];
+	request.headers.forEach((value, key) => {
+		headers.push([key, value]);
+	});
+	let body;
+	if (request.body === null) body = { kind: "none" };
+	else {
+		const contentType = request.headers.get("content-type");
+		if (contentType && isTextContentType(contentType)) body = {
+			kind: "text",
+			value: await request.text()
+		};
+		else body = {
+			kind: "arrayBuffer",
+			value: await request.arrayBuffer()
+		};
+	}
+	return {
+		method: request.method,
+		path: url.pathname + url.search,
+		headers,
+		body
+	};
+};
+const toResponse = (payload) => {
+	let body = null;
+	if (payload.body.kind === "text") body = payload.body.value;
+	else if (payload.body.kind === "arrayBuffer") body = payload.body.value;
+	const headers = payload.headers.map(([k, v]) => [k, v]);
+	return new Response(body, {
+		status: payload.status,
+		statusText: payload.statusText,
+		headers
+	});
+};
+const DEFAULT_IPC_CHANNEL = "http://zelt-ipc";
+/**
+* @throws {Error} when the IPC sender is not registered for the given channel
+*/ const ipcFetch = async (input, init, options) => {
+	const channel = options?.channel ?? DEFAULT_IPC_CHANNEL;
+	const senderCandidate = Reflect.get(globalThis, channel);
+	if (typeof senderCandidate !== "function") throw new Error(`IPC sender not found for channel "${channel}". Did you call exposeIpc() in the preload script?`);
+	const ipcRequest = await toIpcRequest(input, init);
+	return toResponse(await senderCandidate.call(null, ipcRequest));
+};
+//#endregion
+export { ipcFetch, toIpcRequest, toResponse };
+
+//# sourceMappingURL=index.js.map

package/dist/renderer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["TEXT_CONTENT_TYPE_PREFIXES","isTextContentType","contentType","some","prefix","startsWith","toIpcRequest","input","init","request","Request","url","URL","headers","forEach","value","key","push","body","kind","get","text","arrayBuffer","method","path","pathname","search","toResponse","payload","map","k","v","Response","status","statusText","DEFAULT_IPC_CHANNEL","ipcFetch","options","channel","senderCandidate","Reflect","globalThis","Error","ipcRequest","call"],"sources":["../../src/renderer/ipc-fetch.ts"],"sourcesContent":["import type { IpcBody, IpcFetchRequest, IpcFetchResponse } from '../shared/ipc.types';\n\nconst TEXT_CONTENT_TYPE_PREFIXES = [\n  'text/',\n  'application/json',\n  'application/xml',\n  'application/javascript',\n  'application/x-www-form-urlencoded',\n];\n\nconst isTextContentType = (contentType: string): boolean =>\n  TEXT_CONTENT_TYPE_PREFIXES.some((prefix) => contentType.startsWith(prefix));\n\nexport const toIpcRequest = async (\n  input: RequestInfo | URL,\n  init?: RequestInit,\n): Promise<IpcFetchRequest> => {\n  const request = new Request(input, init);\n  const url = new URL(request.url);\n\n  const headers: [string, string][] = [];\n  request.headers.forEach((value, key) => {\n    headers.push([key, value]);\n  });\n\n  let body: IpcBody;\n  if (request.body === null) {\n    body = { kind: 'none' };\n  } else {\n    const contentType = request.headers.get('content-type');\n    if (contentType && isTextContentType(contentType)) {\n      body = { kind: 'text', value: await request.text() };\n    } else {\n      body = { kind: 'arrayBuffer', value: await request.arrayBuffer() };\n    }\n  }\n\n  return {\n    method: request.method,\n    path: url.pathname + url.search,\n    headers,\n    body,\n  };\n};\n\nexport const toResponse = (payload: IpcFetchResponse): Response => {\n  let body: BodyInit | null = null;\n  if (payload.body.kind === 'text') {\n    body = payload.body.value;\n  } else if (payload.body.kind === 'arrayBuffer') {\n    body = payload.body.value;\n  }\n\n  const headers: [string, string][] = payload.headers.map(([k, v]) => [k, v]);\n  return new Response(body, {\n    status: payload.status,\n    statusText: payload.statusText,\n    headers,\n  });\n};\n\nconst DEFAULT_IPC_CHANNEL = 'http://zelt-ipc';\n\nexport type IpcFetchOptions = {\n  readonly channel?: string;\n};\n\n/**\n * @throws {Error} when the IPC sender is not registered for the given channel\n */\nexport const ipcFetch = async (\n  input: RequestInfo | URL,\n  init?: RequestInit,\n  options?: IpcFetchOptions,\n): Promise<Response> => {\n  const channel = options?.channel ?? DEFAULT_IPC_CHANNEL;\n  const senderCandidate: unknown = Reflect.get(globalThis, channel);\n\n  if (typeof senderCandidate !== 'function') {\n    throw new Error(\n      `IPC sender not found for channel \"${channel}\". Did you call exposeIpc() in the preload script?`,\n    );\n  }\n\n  const ipcRequest = await toIpcRequest(input, init);\n  return toResponse(await senderCandidate.call(null, ipcRequest));\n};\n"],"mappings":";AAEA,MAAMA,6BAA6B;CACjC;CACA;CACA;CACA;CACA;CACD;AAED,MAAMC,qBAAqBC,gBACzBF,2BAA2BG,MAAMC,WAAWF,YAAYG,WAAWD,OAAAA,CAAAA;AAErE,MAAaE,eAAe,OAC1BC,OACAC,SAAAA;CAEA,MAAMC,UAAU,IAAIC,QAAQH,OAAOC,KAAAA;CACnC,MAAMG,MAAM,IAAIC,IAAIH,QAAQE,IAAG;CAE/B,MAAME,UAA8B,EAAE;AACtCJ,SAAQI,QAAQC,SAASC,OAAOC,QAAAA;AAC9BH,UAAQI,KAAK,CAACD,KAAKD,MAAM,CAAA;GAC3B;CAEA,IAAIG;AACJ,KAAIT,QAAQS,SAAS,KACnBA,QAAO,EAAEC,MAAM,QAAO;MACjB;EACL,MAAMjB,cAAcO,QAAQI,QAAQO,IAAI,eAAA;AACxC,MAAIlB,eAAeD,kBAAkBC,YAAAA,CACnCgB,QAAO;GAAEC,MAAM;GAAQJ,OAAO,MAAMN,QAAQY,MAAI;GAAG;MAEnDH,QAAO;GAAEC,MAAM;GAAeJ,OAAO,MAAMN,QAAQa,aAAW;GAAG;;AAIrE,QAAO;EACLC,QAAQd,QAAQc;EAChBC,MAAMb,IAAIc,WAAWd,IAAIe;EACzBb;EACAK;EACF;;AAGF,MAAaS,cAAcC,YAAAA;CACzB,IAAIV,OAAwB;AAC5B,KAAIU,QAAQV,KAAKC,SAAS,OACxBD,QAAOU,QAAQV,KAAKH;UACXa,QAAQV,KAAKC,SAAS,cAC/BD,QAAOU,QAAQV,KAAKH;CAGtB,MAAMF,UAA8Be,QAAQf,QAAQgB,KAAK,CAACC,GAAGC,OAAO,CAACD,GAAGC,EAAE,CAAA;AAC1E,QAAO,IAAIC,SAASd,MAAM;EACxBe,QAAQL,QAAQK;EAChBC,YAAYN,QAAQM;EACpBrB;EACF,CAAA;;AAGF,MAAMsB,sBAAsB;;;GAS5B,MAAaC,WAAW,OACtB7B,OACAC,MACA6B,YAAAA;CAEA,MAAMC,UAAUD,SAASC,WAAWH;CACpC,MAAMI,kBAA2BC,QAAQpB,IAAIqB,YAAYH,QAAAA;AAEzD,KAAI,OAAOC,oBAAoB,WAC7B,OAAM,IAAIG,MACR,qCAAqCJ,QAAQ,oDAAmD;CAIpG,MAAMK,aAAa,MAAMrC,aAAaC,OAAOC,KAAAA;AAC7C,QAAOmB,WAAW,MAAMY,gBAAgBK,KAAK,MAAMD,WAAAA,CAAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeltjs/adapter-electron",
-  "version": "0.8.1",
+  "version": "0.8.2-canary.1",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -13,15 +13,43 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": {
+        "types": "./dist/main/index.d.ts",
+        "default": "./dist/main/index.js"
+      },
+      "require": {
+        "types": "./dist/main/index.d.cts",
+        "default": "./dist/main/index.cjs"
+      }
+    },
+    "./preload": {
+      "import": {
+        "types": "./dist/preload/index.d.ts",
+        "default": "./dist/preload/index.js"
+      },
+      "require": {
+        "types": "./dist/preload/index.d.cts",
+        "default": "./dist/preload/index.cjs"
+      }
+    },
+    "./renderer": {
+      "import": {
+        "types": "./dist/renderer/index.d.ts",
+        "default": "./dist/renderer/index.js"
+      },
+      "require": {
+        "types": "./dist/renderer/index.d.cts",
+        "default": "./dist/renderer/index.cjs"
+      }
     }
   },
+  "main": "./dist/main/index.cjs",
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@zeltjs/core": "0.8.1"
+    "ts-pattern": "5.7.1",
+    "@zeltjs/core": "0.8.2-canary.1"
   },
   "devDependencies": {
     "@types/node": "22.19.17"
@@ -29,11 +57,6 @@
   "peerDependencies": {
     "electron": ">=28.0.0"
   },
-  "peerDependenciesMeta": {
-    "electron": {
-      "optional": true
-    }
-  },
   "volta": {
     "extends": "../../package.json"
   },

package/dist/index.d.ts

@@ -1,19 +0,0 @@
-import { EnvAdaptor, HttpApp, ReadyResult } from "@zeltjs/core";
-
-//#region src/electron-env.adaptor.d.ts
-declare class ElectronEnvAdaptor extends EnvAdaptor {
-  get(key: string): string | undefined;
-}
-//#endregion
-//#region src/on-electron.d.ts
-type ElectronAppOptions = {
-  readonly warmup?: boolean;
-};
-type ElectronApp = ReadyResult & {
-  readonly fetch: (request: Request) => Promise<Response>;
-  readonly shutdown: () => Promise<void>;
-};
-declare const onElectron: (app: HttpApp, options?: ElectronAppOptions) => Promise<ElectronApp>;
-//#endregion
-export { type ElectronApp, type ElectronAppOptions, ElectronEnvAdaptor, onElectron };
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/electron-env.adaptor.ts","../src/on-electron.ts"],"mappings":";;;cAGa,kBAAA,SAA2B,UAAA;EAC7B,GAAA,CAAI,GAAA;AAAA;;;KCAH,kBAAA;EAAA,SACD,MAAA;AAAA;AAAA,KAGC,WAAA,GAAc,WAAA;EAAA,SACf,KAAA,GAAQ,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;EAAA,SACrC,QAAA,QAAgB,OAAA;AAAA;AAAA,cAGd,UAAA,GACX,GAAA,EAAK,OAAA,EACL,OAAA,GAAS,kBAAA,KACR,OAAA,CAAQ,WAAA"}

package/dist/index.js

@@ -1,29 +0,0 @@
-import { Config, EnvAdaptor } from "@zeltjs/core";
-//#region src/electron-env.adaptor.ts
-function _ts_decorate(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 ElectronEnvAdaptor = class extends EnvAdaptor {
-	get(key) {
-		return process.env[key];
-	}
-};
-ElectronEnvAdaptor = _ts_decorate([Config], ElectronEnvAdaptor);
-//#endregion
-//#region src/on-electron.ts
-const onElectron = async (app, options = {}) => {
-	app.addFallbackConfig(ElectronEnvAdaptor);
-	const readyOptions = { warmup: options.warmup ?? true };
-	return {
-		...await app.ready(readyOptions),
-		fetch: app.fetch,
-		shutdown: app.shutdown
-	};
-};
-//#endregion
-export { ElectronEnvAdaptor, onElectron };
-
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["Config","EnvAdaptor","ElectronEnvAdaptor","get","key","process","env","ElectronEnvAdaptor","onElectron","app","options","addFallbackConfig","readyOptions","warmup","resolver","ready","fetch","shutdown"],"sources":["../src/electron-env.adaptor.ts","../src/on-electron.ts"],"sourcesContent":["import { Config, EnvAdaptor } from '@zeltjs/core';\n\n@Config\nexport class ElectronEnvAdaptor extends EnvAdaptor {\n  override get(key: string): string | undefined {\n    return process.env[key];\n  }\n}\n","import type { HttpApp, ReadyOptions, ReadyResult } from '@zeltjs/core';\n\nimport { ElectronEnvAdaptor } from './electron-env.adaptor';\n\nexport type ElectronAppOptions = {\n  readonly warmup?: boolean;\n};\n\nexport type ElectronApp = ReadyResult & {\n  readonly fetch: (request: Request) => Promise<Response>;\n  readonly shutdown: () => Promise<void>;\n};\n\nexport const onElectron = async (\n  app: HttpApp,\n  options: ElectronAppOptions = {},\n): Promise<ElectronApp> => {\n  app.addFallbackConfig(ElectronEnvAdaptor);\n\n  const readyOptions: ReadyOptions = { warmup: options.warmup ?? true };\n  const resolver = await app.ready(readyOptions);\n\n  return {\n    ...resolver,\n    fetch: app.fetch,\n    shutdown: app.shutdown,\n  };\n};\n"],"mappings":";;;;;;;;AAGA,IAAaE,qBAAb,cAAwCD,WAAAA;CAC7BE,IAAIC,KAAiC;AAC5C,SAAOC,QAAQC,IAAIF;;;;;;ACQvB,MAAaI,aAAa,OACxBC,KACAC,UAA8B,EAAE,KAAA;AAEhCD,KAAIE,kBAAkBJ,mBAAAA;CAEtB,MAAMK,eAA6B,EAAEC,QAAQH,QAAQG,UAAU,MAAK;AAGpE,QAAO;EACL,GAAGC,MAHkBL,IAAIM,MAAMH,aAAAA;EAI/BI,OAAOP,IAAIO;EACXC,UAAUR,IAAIQ;EAChB"}