@witchcraft/nuxt-electron 0.2.3 → 0.2.5

package/README.md

@@ -10,8 +10,8 @@
 ## Features
 
 - :zap: Auto reloads/restarts electron on changes to the main/renderer code or nuxt server restarts.
-- :rocket: Api calls are proxied to the server.
-- :start: Rendering strategy isn't changed. Does not require static builds or changing baseURL/buildAssetsDir. 
+- :rocket: Api calls are proxied to the server (you can also easily proxy other requests).
+- :star: Rendering strategy isn't changed. Does not require static builds or changing baseURL/buildAssetsDir. 
 - :scissors: Trims server and non-electron routes from the electron bundle.
 - :open_file_folder: Modifies directory structure for easier multi-platform builds.
 - :snowflake: Nix Support - Playground contains an example flake for reproducible development and builds.
@@ -26,7 +26,7 @@
 		- Various helpers for setting up apis such as:
 			- `createBroadcasters/createBroadcastHandlers` for sending messages to all windows.
 			- `createWindowControlsApi` for calling close/minimize/maximize/pin from the renderer and an `ElectronWindowControls` component for rending a basic set.
-			- `promisifyApi`(preload) and `promisifyReply`(main) for easily creating and handling apis in the preload script.
+			- `createApi`(preload) and `handleApi`(main) for easily creating and handling apis in the preload script.
 	- See also [@witchcraft/nuxt-logger](https://github.com/witchcraftjs/nuxt-logger) for electron logging utilities.
 
 # Playground
@@ -61,7 +61,12 @@ See [#Usage on Nix](#Usage-on-Nix) for more details.
 ## Install
 ```bash
 pnpx nuxi module add @witchcraft/nuxt-electron
+```
+
+Be sure to shamefully hoist if using pnpm:
 
+```rc [.npmrc]
+shamefully-hoist=true
 ```
 ### Components
 

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "electron",
   "configKey": "electron",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/electron/createApi.d.ts

@@ -0,0 +1,74 @@
+import type { ElectronIpcMessages } from "./types.js";
+/**
+ * Type safe wrapper around ipcRenderer.invoke which also creates the api function at the proper path.
+ *
+ * This makes every single part of the api type safe while avoiding repetition.
+ *
+ * ```ts [preload.ts]
+ * import { mergeApi, createApi } from "@witchcraft/nuxt-electron/electron"
+ *
+ * declare module "@witchcraft/nuxt-electron" {
+ * 	interface Register {
+ * 		ElectronIpcTestMethod: {
+ * 			path: "my.test.method"
+ * 			func: (arg1: string, arg2: number) => Promise<void>
+ * 			prefix: "avoidConflict" // optional (and yes you can do avoid.conflict and have it nested further)
+ * 		}
+ * 	}
+ * }
+ *
+ * contextBridge.exposeInMainWorld("electron", {
+ * 	api: mergeApi(
+ * 		createApi("my.test.method"), // returns { "my.test.method": (...args: any[]) => Promise<void> }
+ * 		createApi("avoidConflict.my.test.method") // returns { "avoidConflict.my.test.method": (...args: any[]) => Promise<void> }
+ * 	),
+ * 	// mergeApi creates a structure like:
+ * 	// {
+ * 	// 	my: {
+ * 	// 		test: {
+ * 	// 			method: (arg1: string, arg2: number) => Promise<void>
+ * 	// 		}
+ * 	// 	},
+ * 	// 	avoidConflict: {
+ * 	// 		my: {
+ * 	// 			test: {
+ * 	// 				method: (arg1: string, arg2: number) => Promise<void>
+ * 	// 			}
+ * 	// 		}
+ * 	// 	}
+ * 	// }
+ * })
+ * ```
+ *
+ * ```ts [main.ts]
+ * import { createApi } from "@witchcraft/nuxt-electron/electron"
+ * ipcHandle("my.test.method", (event, arg1, arg2) => { ... })
+ * ipcHandle("avoidConflict.my.test.method", (event, arg1, arg2) => { ... })
+ * ```
+ *
+ * Add the window types:
+ * ```ts [global.d.ts]
+ * import type { ElectronIpcWindowApi } from "@witchcraft/nuxt-electron/electron"
+ *
+ * declare global {
+ * 	interface Window {
+ * 		electron: {
+ * 			api: ElectronIpcWindowApi
+ * 		}
+ * 	}
+ * }
+ *
+ * export {}
+ * ```
+ *
+ * Use from the renderer:
+ * ```ts [renderer.ts]
+ * const res = await window.electron.api.my.test.method("hello", 123)
+ * const res2 = await window.electron.avoidConflict.api.my.test.method("hello", 123)
+ * ```
+ */
+export declare function createApi<TKey extends keyof ElectronIpcMessages, TEntry extends ElectronIpcMessages[TKey] = ElectronIpcMessages[TKey], TPrefix extends string = TEntry extends {
+    prefix: infer P extends string;
+} ? P : "", TPath extends string = TEntry["path"], TFunction extends TEntry["func"] = TEntry["func"]>(path: TPath, prefix?: TPrefix): {
+    [K in `${TPrefix}${TPath}`]: TFunction;
+};

package/dist/runtime/electron/createApi.js

@@ -0,0 +1,8 @@
+import { set } from "@alanscodelog/utils/set";
+import { ipcRenderer } from "electron";
+export function createApi(path, prefix = "") {
+  const res = {};
+  const fullPath = prefix !== "" ? `${prefix}.${path}` : path;
+  set(res, fullPath.split("."), (...args) => ipcRenderer.invoke(fullPath, ...args));
+  return res;
+}

package/dist/runtime/electron/createProxiedProtocolHandler.js

@@ -47,11 +47,6 @@ export function createProxiedProtocolHandler(protocol, protocolName = "app", bas
   if (protocol.isProtocolHandled(protocolName)) {
     throw new Error(`Protocol ${protocolName} is already handled.`);
   }
-  if (routeProxyKeys.length > 0) {
-    if (!process.env.PUBLIC_SERVER_URL && !process.env.VITE_DEV_URL && !process.env.PUBLIC_SERVER_URL) {
-      throw new Error("You defined proxy routes but didn't set PUBLIC_SERVER_URL or VITE_DEV_URL set. This is required for the /api routes to work.");
-    }
-  }
   let errorPage404;
   protocol.handle(protocolName, async (request) => {
     errorPage404 ??= await getFromCacheOr(cache, "404.html", (key) => getPathToServe(path.join(basePath, errorPage), "404.html", key, logger), logger);

package/dist/runtime/electron/getPaths.js

@@ -23,7 +23,7 @@ export function getPaths(protocolName = "app", overridingEnvs = {
       windowUrl: `${overridingEnvs.windowUrl}${STATIC.ELECTRON_ROUTE}`
     };
   }
-  if (process.env.NODE_ENV === "production" && process.env.VITE_DEV_SERVER_URL) {
+  if (process.env.NODE_ENV !== "production" && process.env.VITE_DEV_SERVER_URL) {
     return {
       ...base,
       windowUrl: `${process.env.VITE_DEV_SERVER_URL}${STATIC.ELECTRON_ROUTE}`

package/dist/runtime/electron/handleApi.d.ts

@@ -0,0 +1,5 @@
+import type { ElectronIpcMessages } from "./types.js";
+/**
+ * Type safe wrapper around ipcMain.handle. See {@link createApi} for more info.
+ */
+export declare function handleApi<TFullPath extends keyof ElectronIpcMessages, TFunction extends ElectronIpcMessages[TFullPath]["func"]>(path: TFullPath, cb: (event: Electron.IpcMainInvokeEvent, ...args: Parameters<TFunction>) => ReturnType<TFunction> | Awaited<ReturnType<TFunction>>): void;

package/dist/runtime/electron/handleApi.js

@@ -0,0 +1,4 @@
+import { ipcMain } from "electron";
+export function handleApi(path, cb) {
+  ipcMain.handle(path, cb);
+}

package/dist/runtime/electron/index.d.ts

@@ -1,17 +1,20 @@
 export * from "./types";
-export { getPaths } from "./getPaths";
-export { createProxiedProtocolHandler } from "./createProxiedProtocolHandler";
+export { STATIC } from "./static";
+export { apiBuilder } from "./apiBuilder";
+export { createApi } from "./createApi";
+export { createBroadcastHandlers } from "./createBroadcastHandlers";
+export { createBroadcaster } from "./createBroadcaster";
 export { createPrivilegedProtocolScheme } from "./createPrivilegedProtocolScheme";
+export { createProxiedProtocolHandler } from "./createProxiedProtocolHandler";
 export { createWindowControlsApi } from "./createWindowControlsApi";
 export { createWindowControlsApiHandler } from "./createWindowControlsApiHandler";
-export { useNuxtRuntimeConfig } from "./useNuxtRuntimeConfig";
-export { STATIC } from "./static";
-export { apiBuilder } from "./apiBuilder";
-export { useDevDataDir } from "./useDevDataDir";
-export { registerDevtoolsShortcuts } from "./registerDevtoolsShortcuts";
-export { promisifyApi } from "./promisifyApi";
-export { getPreloadMeta } from "./getPreloadMeta";
 export { getEventWindow } from "./getEventWindow";
+export { getPaths } from "./getPaths";
+export { getPreloadMeta } from "./getPreloadMeta";
+export { handleApi } from "./handleApi";
+export { mergeApi } from "./mergeApi";
+export { promisifyApi } from "./promisifyApi";
 export { promisifyReply } from "./promisifyReply";
-export { createBroadcaster } from "./createBroadcaster";
-export { createBroadcastHandlers } from "./createBroadcastHandlers";
+export { registerDevtoolsShortcuts } from "./registerDevtoolsShortcuts";
+export { useDevDataDir } from "./useDevDataDir";
+export { useNuxtRuntimeConfig } from "./useNuxtRuntimeConfig";

package/dist/runtime/electron/index.js

@@ -1,17 +1,20 @@
 export * from "./types.js";
-export { getPaths } from "./getPaths.js";
-export { createProxiedProtocolHandler } from "./createProxiedProtocolHandler.js";
+export { STATIC } from "./static.js";
+export { apiBuilder } from "./apiBuilder.js";
+export { createApi } from "./createApi.js";
+export { createBroadcastHandlers } from "./createBroadcastHandlers.js";
+export { createBroadcaster } from "./createBroadcaster.js";
 export { createPrivilegedProtocolScheme } from "./createPrivilegedProtocolScheme.js";
+export { createProxiedProtocolHandler } from "./createProxiedProtocolHandler.js";
 export { createWindowControlsApi } from "./createWindowControlsApi.js";
 export { createWindowControlsApiHandler } from "./createWindowControlsApiHandler.js";
-export { useNuxtRuntimeConfig } from "./useNuxtRuntimeConfig.js";
-export { STATIC } from "./static.js";
-export { apiBuilder } from "./apiBuilder.js";
-export { useDevDataDir } from "./useDevDataDir.js";
-export { registerDevtoolsShortcuts } from "./registerDevtoolsShortcuts.js";
-export { promisifyApi } from "./promisifyApi.js";
-export { getPreloadMeta } from "./getPreloadMeta.js";
 export { getEventWindow } from "./getEventWindow.js";
+export { getPaths } from "./getPaths.js";
+export { getPreloadMeta } from "./getPreloadMeta.js";
+export { handleApi } from "./handleApi.js";
+export { mergeApi } from "./mergeApi.js";
+export { promisifyApi } from "./promisifyApi.js";
 export { promisifyReply } from "./promisifyReply.js";
-export { createBroadcaster } from "./createBroadcaster.js";
-export { createBroadcastHandlers } from "./createBroadcastHandlers.js";
+export { registerDevtoolsShortcuts } from "./registerDevtoolsShortcuts.js";
+export { useDevDataDir } from "./useDevDataDir.js";
+export { useNuxtRuntimeConfig } from "./useNuxtRuntimeConfig.js";

package/dist/runtime/electron/mergeApi.d.ts

@@ -0,0 +1,2 @@
+import type { Flatten, OrToAnd } from "@alanscodelog/utils/types";
+export declare function mergeApi<T extends Record<string, any>[]>(...apis: T): Flatten<OrToAnd<T[number]>>;

package/dist/runtime/electron/mergeApi.js

@@ -0,0 +1,18 @@
+import { get } from "@alanscodelog/utils/get";
+import { set } from "@alanscodelog/utils/set";
+import { walk } from "@alanscodelog/utils/walk";
+export function mergeApi(...apis) {
+  const result = {};
+  for (const api of apis) {
+    walk(api, (el, keyPath) => {
+      const value = get(result, keyPath);
+      const canExtend = typeof value === "object" || typeof value === "undefined";
+      if (!canExtend) {
+        throw new Error(`Value (${typeof value}) in way of keypath ${keyPath.join(".")}`);
+      } else {
+        set(result, keyPath, el);
+      }
+    });
+  }
+  return result;
+}

package/dist/runtime/electron/promisifyApi.d.ts

@@ -2,7 +2,7 @@ import type { IpcRenderer } from "electron";
 /**
  * Promisify an electron api and make it type safe so it can be awaited client side. Note that promisifyReply will throw if it can't find a window.
  *
- * ```ts[type.st]
+ * ```ts[types.ts]
  * export type ElectronApi = {
  * 	api: {
  * 		someApi: (apiParam: string, apiParam2: number) => Promise<void>
@@ -18,7 +18,7 @@ import type { IpcRenderer } from "electron";
  * ```
  *
  * ```ts [main.ts]
- * import { promisifyReply } from "@witchcraft/nuxt-electron/runtime/electron"
+ * import { promisifyReply } from "@witchcraft/nuxt-electron/electron"
  * promisifyReply<
  * 	ElectronApi["api"]["someApi"]
  * >(ipcRenderer, MESSAGE.UNIQUE_KEY, (win, apiParam, apiParam2) => {
@@ -33,6 +33,8 @@ import type { IpcRenderer } from "electron";
  * ```
  *
  * By default, calls will timeout and reject after 10 seconds. This can be changed by changing the timeout option.
+ *
+ * @deprecated Use {@link createApi} instead.
  */
 export declare function promisifyApi<TKey extends string, TFunction extends (...args: any) => Promise<any>, TArgs extends Parameters<TFunction> = Parameters<TFunction>>(ipcRenderer: IpcRenderer, key: TKey, messageKey: string, modifyArgs?: (args: TArgs) => any, { debug, timeout }?: {
     debug?: boolean;

package/dist/runtime/electron/promisifyReply.d.ts

@@ -1,5 +1,9 @@
 import { type BrowserWindow } from "electron";
-/** See {@link promisifyApi} for more info. */
+/**
+ * See {@link promisifyApi} for more info.
+ *
+ * @deprecated Use {@link handleApi} instead.
+ */
 export declare function promisifyReply<TFunction extends ((...args: any[]) => any), TKey extends string = string, TArgs extends Parameters<TFunction> = Parameters<TFunction>, TReturn extends ReturnType<TFunction> = ReturnType<TFunction>>(key: TKey, cb: (win?: BrowserWindow, ...args: TArgs) => Promise<TReturn> | TReturn, 
 /** See {@link getEventWindow}. */
 { defaultToFocused, debug }?: {

package/dist/runtime/electron/types.d.ts

@@ -1 +1,25 @@
+import type { AnyFunction, Flatten, OrToAnd } from "@alanscodelog/utils/types";
 export type WindowControlsApi = (action: "close" | "minimize" | "toggleMaximize" | "togglePin") => Promise<void>;
+export interface Register {
+}
+export type ElectronIpcMessages = Flatten<OrToAnd<{
+    [K in keyof Register as K extends `ElectronIpc${string}` ? K : never]: Register[K] extends {
+        func: infer TFunc extends AnyFunction;
+        path: infer TPath extends string;
+    } ? {
+        [K2 in Register[K] extends {
+            prefix: string;
+        } ? `${Register[K]["prefix"]}.${Register[K]["path"]}` : Register[K]["path"]]: {
+            func: TFunc;
+            path: TPath;
+        };
+    } : never;
+}[keyof Register & `ElectronIpc${string}`] | {}>>;
+export type PathToObject<TPath extends string, TValue> = TPath extends `${infer Head}.${infer Tail}` ? {
+    [K in Head]: PathToObject<Tail, TValue>;
+} : {
+    [K in TPath]: TValue;
+};
+export type ElectronIpcWindowApi = Flatten<OrToAnd<{
+    [K in keyof ElectronIpcMessages]: PathToObject<K, ElectronIpcMessages[K]["func"]>;
+}[keyof ElectronIpcMessages]>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@witchcraft/nuxt-electron",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Nuxt module for working with electron.",
   "repository": "https://github.com/witchcraftjs/nuxt-electron",
   "license": "MIT",
@@ -25,7 +25,7 @@
     "genDevDesktop.js"
   ],
   "dependencies": {
-    "@alanscodelog/utils": "^6.0.2",
+    "@alanscodelog/utils": "^6.2.0",
     "@nuxt/kit": "^4.3.1",
     "@witchcraft/nuxt-utils": "^0.3.6",
     "@witchcraft/ui": "^0.3.24",
@@ -50,7 +50,7 @@
   "devDependencies": {
     "@alanscodelog/eslint-config": "^6.3.1",
     "@alanscodelog/semantic-release-config": "^6.0.2",
-    "@alanscodelog/tsconfigs": "^6.2.0",
+    "@alanscodelog/tsconfigs": "^6.3.0",
     "@nuxt/eslint-config": "^1.15.1",
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "^4.3.1",
@@ -88,7 +88,6 @@
     "lint": "pnpm lint:eslint && pnpm lint:types",
     "lint:eslint": "eslint \"{src,test,playground/app}/**/*.{ts,vue}\" \"*.{js,cjs,mjs,ts}\"",
     "lint:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest watch"
+    "test": "echo \"No tests\""
   }
 }

package/src/runtime/electron/createApi.ts

@@ -0,0 +1,89 @@
+import { set } from "@alanscodelog/utils/set"
+import { ipcRenderer } from "electron"
+
+import type { ElectronIpcMessages } from "./types.js"
+
+/**
+ * Type safe wrapper around ipcRenderer.invoke which also creates the api function at the proper path.
+ *
+ * This makes every single part of the api type safe while avoiding repetition.
+ *
+ * ```ts [preload.ts]
+ * import { mergeApi, createApi } from "@witchcraft/nuxt-electron/electron"
+ *
+ * declare module "@witchcraft/nuxt-electron" {
+ * 	interface Register {
+ * 		ElectronIpcTestMethod: {
+ * 			path: "my.test.method"
+ * 			func: (arg1: string, arg2: number) => Promise<void>
+ * 			prefix: "avoidConflict" // optional (and yes you can do avoid.conflict and have it nested further)
+ * 		}
+ * 	}
+ * }
+ *
+ * contextBridge.exposeInMainWorld("electron", {
+ * 	api: mergeApi(
+ * 		createApi("my.test.method"), // returns { "my.test.method": (...args: any[]) => Promise<void> }
+ * 		createApi("avoidConflict.my.test.method") // returns { "avoidConflict.my.test.method": (...args: any[]) => Promise<void> }
+ * 	),
+ * 	// mergeApi creates a structure like:
+ * 	// {
+ * 	// 	my: {
+ * 	// 		test: {
+ * 	// 			method: (arg1: string, arg2: number) => Promise<void>
+ * 	// 		}
+ * 	// 	},
+ * 	// 	avoidConflict: {
+ * 	// 		my: {
+ * 	// 			test: {
+ * 	// 				method: (arg1: string, arg2: number) => Promise<void>
+ * 	// 			}
+ * 	// 		}
+ * 	// 	}
+ * 	// }
+ * })
+ * ```
+ *
+ * ```ts [main.ts]
+ * import { createApi } from "@witchcraft/nuxt-electron/electron"
+ * ipcHandle("my.test.method", (event, arg1, arg2) => { ... })
+ * ipcHandle("avoidConflict.my.test.method", (event, arg1, arg2) => { ... })
+ * ```
+ *
+ * Add the window types:
+ * ```ts [global.d.ts]
+ * import type { ElectronIpcWindowApi } from "@witchcraft/nuxt-electron/electron"
+ *
+ * declare global {
+ * 	interface Window {
+ * 		electron: {
+ * 			api: ElectronIpcWindowApi
+ * 		}
+ * 	}
+ * }
+ *
+ * export {}
+ * ```
+ *
+ * Use from the renderer:
+ * ```ts [renderer.ts]
+ * const res = await window.electron.api.my.test.method("hello", 123)
+ * const res2 = await window.electron.avoidConflict.api.my.test.method("hello", 123)
+ * ```
+ */
+export function createApi<
+	TKey extends keyof ElectronIpcMessages,
+	TEntry extends ElectronIpcMessages[TKey] = ElectronIpcMessages[TKey],
+	// Extract prefix if it exists, otherwise default to empty string
+	TPrefix extends string = TEntry extends { prefix: infer P extends string } ? P : "",
+	TPath extends string = TEntry["path"],
+	TFunction extends TEntry["func"] = TEntry["func"]
+>(
+	path: TPath,
+	prefix: TPrefix = "" as any
+): { [K in `${TPrefix}${TPath}`]: TFunction } {
+	const res: any = {}
+	const fullPath = prefix !== "" ? `${prefix}.${path}` : path
+	set(res, fullPath.split("."), (...args: Parameters<TFunction>) => ipcRenderer.invoke(fullPath, ...args))
+	return res
+}

package/src/runtime/electron/createProxiedProtocolHandler.ts

@@ -129,11 +129,6 @@ export function createProxiedProtocolHandler(
 	if (protocol.isProtocolHandled(protocolName)) {
 		throw new Error(`Protocol ${protocolName} is already handled.`)
 	}
-	if (routeProxyKeys.length > 0) {
-		if (!process.env.PUBLIC_SERVER_URL && !process.env.VITE_DEV_URL && !process.env.PUBLIC_SERVER_URL) {
-			throw new Error("You defined proxy routes but didn't set PUBLIC_SERVER_URL or VITE_DEV_URL set. This is required for the /api routes to work.")
-		}
-	}
 
 	let errorPage404: string | undefined
 	// note that while it would be nice to do protocol.isProtocolRegistered

package/src/runtime/electron/getPaths.ts

@@ -56,7 +56,7 @@ export function getPaths(
 		}
 	}
 
-	if (process.env.NODE_ENV === "production" && process.env.VITE_DEV_SERVER_URL) {
+	if (process.env.NODE_ENV !== "production" && process.env.VITE_DEV_SERVER_URL) {
 		return {
 			...base,
 			windowUrl: `${process.env.VITE_DEV_SERVER_URL}${STATIC.ELECTRON_ROUTE}`

package/src/runtime/electron/handleApi.ts

@@ -0,0 +1,19 @@
+import { ipcMain } from "electron"
+
+import type { ElectronIpcMessages } from "./types.js"
+
+/**
+ * Type safe wrapper around ipcMain.handle. See {@link createApi} for more info.
+ */
+export function handleApi<
+	TFullPath extends keyof ElectronIpcMessages,
+	TFunction extends ElectronIpcMessages[TFullPath]["func"]
+>(
+	path: TFullPath,
+	// it can return a plain value or a promise that will resolve to that value
+	// since it's promisified anyways
+	cb: (event: Electron.IpcMainInvokeEvent, ...args: Parameters<TFunction>) => ReturnType<TFunction> | Awaited<ReturnType<TFunction>>
+): void {
+	ipcMain.handle(path, cb)
+}
+

package/src/runtime/electron/index.ts

@@ -1,18 +1,21 @@
 export * from "./types"
 // note adding file endings breaks build types
-export { getPaths } from "./getPaths"
-export { createProxiedProtocolHandler } from "./createProxiedProtocolHandler"
+export { STATIC } from "./static"
+export { apiBuilder } from "./apiBuilder"
+export { createApi } from "./createApi"
+export { createBroadcastHandlers } from "./createBroadcastHandlers"
+export { createBroadcaster } from "./createBroadcaster"
 export { createPrivilegedProtocolScheme } from "./createPrivilegedProtocolScheme"
+export { createProxiedProtocolHandler } from "./createProxiedProtocolHandler"
 export { createWindowControlsApi } from "./createWindowControlsApi"
 export { createWindowControlsApiHandler } from "./createWindowControlsApiHandler"
-export { useNuxtRuntimeConfig } from "./useNuxtRuntimeConfig"
-export { STATIC } from "./static"
-export { apiBuilder } from "./apiBuilder"
-export { useDevDataDir } from "./useDevDataDir"
-export { registerDevtoolsShortcuts } from "./registerDevtoolsShortcuts"
-export { promisifyApi } from "./promisifyApi"
-export { getPreloadMeta } from "./getPreloadMeta"
 export { getEventWindow } from "./getEventWindow"
+export { getPaths } from "./getPaths"
+export { getPreloadMeta } from "./getPreloadMeta"
+export { handleApi } from "./handleApi"
+export { mergeApi } from "./mergeApi"
+export { promisifyApi } from "./promisifyApi"
 export { promisifyReply } from "./promisifyReply"
-export { createBroadcaster } from "./createBroadcaster"
-export { createBroadcastHandlers } from "./createBroadcastHandlers"
+export { registerDevtoolsShortcuts } from "./registerDevtoolsShortcuts"
+export { useDevDataDir } from "./useDevDataDir"
+export { useNuxtRuntimeConfig } from "./useNuxtRuntimeConfig"

package/src/runtime/electron/mergeApi.ts

@@ -0,0 +1,22 @@
+import { get } from "@alanscodelog/utils/get"
+import { set } from "@alanscodelog/utils/set"
+import type { Flatten, OrToAnd } from "@alanscodelog/utils/types"
+import { walk } from "@alanscodelog/utils/walk"
+
+export function mergeApi<T extends Record<string, any>[]>(
+	...apis: T
+): Flatten<OrToAnd<T[number]>> {
+	const result = {} as any
+	for (const api of apis) {
+		walk(api, (el, keyPath) => {
+			const value = get(result, keyPath)
+			const canExtend = typeof value === "object" || typeof value === "undefined"
+			if (!canExtend) {
+				throw new Error(`Value (${typeof value}) in way of keypath ${keyPath.join(".")}`)
+			} else {
+				set(result, keyPath, el)
+			}
+		})
+	}
+	return result
+}

package/src/runtime/electron/promisifyApi.ts

@@ -8,7 +8,7 @@ const promiseResolveMap = new Map<string, {
 /**
  * Promisify an electron api and make it type safe so it can be awaited client side. Note that promisifyReply will throw if it can't find a window.
  *
- * ```ts[type.st]
+ * ```ts[types.ts]
  * export type ElectronApi = {
  * 	api: {
  * 		someApi: (apiParam: string, apiParam2: number) => Promise<void>
@@ -24,7 +24,7 @@ const promiseResolveMap = new Map<string, {
  * ```
  *
  * ```ts [main.ts]
- * import { promisifyReply } from "@witchcraft/nuxt-electron/runtime/electron"
+ * import { promisifyReply } from "@witchcraft/nuxt-electron/electron"
  * promisifyReply<
  * 	ElectronApi["api"]["someApi"]
  * >(ipcRenderer, MESSAGE.UNIQUE_KEY, (win, apiParam, apiParam2) => {
@@ -39,6 +39,8 @@ const promiseResolveMap = new Map<string, {
  * ```
  *
  * By default, calls will timeout and reject after 10 seconds. This can be changed by changing the timeout option.
+ *
+ * @deprecated Use {@link createApi} instead.
  */
 export function promisifyApi<
 	TKey extends string,

package/src/runtime/electron/promisifyReply.ts

@@ -2,7 +2,11 @@ import { type BrowserWindow, ipcMain } from "electron"
 
 import { getEventWindow } from "./getEventWindow.js"
 
-/** See {@link promisifyApi} for more info. */
+/**
+ * See {@link promisifyApi} for more info.
+ *
+ * @deprecated Use {@link handleApi} instead.
+ */
 export function promisifyReply<
 	TFunction extends ((...args: any[]) => any),
 	TKey extends string = string,

package/src/runtime/electron/types.ts

@@ -1 +1,29 @@
+import type { AnyFunction, Flatten, OrToAnd } from "@alanscodelog/utils/types"
+
 export type WindowControlsApi = (action: "close" | "minimize" | "toggleMaximize" | "togglePin")	=> Promise<void>
+
+export interface Register { }
+
+// this is a version of my extension trick, regular version wasn't working
+export type ElectronIpcMessages = Flatten<OrToAnd<{
+	[K in keyof Register as K extends `ElectronIpc${string}` ? K : never]:
+	Register[K] extends { func: infer TFunc extends AnyFunction, path: infer TPath extends string }
+		? {
+				[K2 in Register[K] extends { prefix: string } ? `${Register[K]["prefix"]}.${Register[K]["path"]}` : Register[K]["path"]]: {
+					func: TFunc
+					path: TPath
+				}
+			}
+		: never
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+}[keyof Register & `ElectronIpc${string}`] | {}>>
+
+export type PathToObject<TPath extends string, TValue>
+	= TPath extends `${infer Head}.${infer Tail}`
+		? { [K in Head]: PathToObject<Tail, TValue> }
+		: { [K in TPath]: TValue }
+
+
+export type ElectronIpcWindowApi = Flatten<OrToAnd<{
+	[K in keyof ElectronIpcMessages]: PathToObject<K, ElectronIpcMessages[K]["func"]>
+}[keyof ElectronIpcMessages]>>