@witchcraft/nuxt-electron 0.0.1

package/dist/runtime/components/WindowControls/MinimizeButton.vue

@@ -0,0 +1,40 @@
+<template>
+<WButton
+	:border="false"
+	aria-label="Minimize"
+	class="
+			p-0
+			[&:hover_.default-icon:after]:bg-accent-500
+			[&:hover_.default-icon:after]:shadow-xs
+			[&:hover_.default-icon:after]:shadow-fg/50
+		"
+	@click="emit('action', 'minimize')"
+>
+	<slot>
+		<div
+			class="
+			default-icon
+			border-fg
+			dark:border-bg
+			w-[var(--electron-wc-size)]
+			h-[var(--electron-wc-size)]
+			relative
+			after:absolute
+			after:content-['']
+			after:bottom-0
+			after:left-0
+			after:w-[var(--electron-wc-size)]
+			after:h-[var(--electron-wc-border)]
+			after:rounded-(--electron-wc-rounded)
+			after:bg-fg
+			dark:after:bg-bg
+
+		"
+		/>
+	</slot>
+</WButton>
+</template>
+
+<script setup>
+const emit = defineEmits(["action"]);
+</script>

package/dist/runtime/components/WindowControls/MinimizeButton.vue.d.ts

@@ -0,0 +1,16 @@
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    action: (action: "minimize") => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onAction?: ((action: "minimize") => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/WindowControls/PinButton.d.vue.ts

@@ -0,0 +1,27 @@
+type __VLS_PublicProps = {
+    /**
+     * If there is a `window.electron.on` api that allows listening to events and main sends an `always-on-top-changed`, it will update the state of the pin.
+     */
+    modelValue?: boolean;
+};
+declare var __VLS_10: {
+    alwaysOnTop: any;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+} & {
+    action: (action: "togglePin") => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onAction?: ((action: "togglePin") => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/WindowControls/PinButton.vue

@@ -0,0 +1,51 @@
+<template>
+<WButton
+	aria-label="Toggle Always On Top"
+	auto-title-from-aria
+	:border="false"
+	:class="twMerge(
+  `
+			p-0
+			hover:text-accent-500
+		`,
+  alwaysOnTop && `
+				[&_.default-icon_svg]:drop-shadow-[0_1px_1px_rgba(0,0,0,0.5)]
+			`,
+  !alwaysOnTop && `
+				text-neutral-400
+				dark:text-neutral-600
+			`
+)"
+
+	@click="emit('action', 'togglePin')"
+>
+	<slot v-bind="{ alwaysOnTop }">
+		<WIcon
+			:class="
+  twMerge(
+    `
+				default-icon
+				w-[var(--electron-wc-size)]
+				h-[var(--electron-wc-size)]
+				flex items-center justify-center
+				scale-105
+			`
+  )
+"
+		>
+			<i-octicon-pin-16/>
+		</WIcon>
+	</slot>
+</WButton>
+</template>
+
+<script setup>
+import { twMerge } from "#imports";
+const emit = defineEmits(["action"]);
+const alwaysOnTop = defineModel({ type: Boolean, ...{ default: false } });
+if (import.meta.client && window?.electron?.on) {
+  window.electron.on("always-on-top-changed", (val) => {
+    alwaysOnTop.value = val;
+  });
+}
+</script>

package/dist/runtime/components/WindowControls/PinButton.vue.d.ts

@@ -0,0 +1,27 @@
+type __VLS_PublicProps = {
+    /**
+     * If there is a `window.electron.on` api that allows listening to events and main sends an `always-on-top-changed`, it will update the state of the pin.
+     */
+    modelValue?: boolean;
+};
+declare var __VLS_10: {
+    alwaysOnTop: any;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+} & {
+    action: (action: "togglePin") => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onAction?: ((action: "togglePin") => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,8 @@
+import type { DeepPartial } from "@alanscodelog/utils";
+import type { IpcRenderer } from "electron";
+/**
+ * Helper for building an api object.
+ *
+ * @experimental
+ */
+export declare function apiBuilder<TPreloadMeta extends Record<string, any>, TRawApi extends Record<string, any> = Record<string, any>, TBuilders extends ((meta: DeepPartial<TPreloadMeta>, ipcRenderer: IpcRenderer) => any)[] = ((meta: DeepPartial<TPreloadMeta>, ipcRenderer: IpcRenderer) => any)[], TBuilderOutput extends ReturnType<TBuilders[number]> = ReturnType<TBuilders[number]>>(ipcRenderer: IpcRenderer, api: TRawApi, meta: TPreloadMeta, builders: TBuilders): TRawApi & TBuilderOutput;

package/dist/runtime/electron/apiBuilder.js

@@ -0,0 +1,9 @@
+import defu from "defu";
+export function apiBuilder(ipcRenderer, api, meta, builders) {
+  const resolutions = [];
+  resolutions.push(api);
+  for (const builder of builders) {
+    resolutions.push(builder(meta, ipcRenderer));
+  }
+  return defu(...resolutions.reverse());
+}

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

@@ -0,0 +1,4 @@
+export declare function createBroadcastHandlers<TEvents extends Record<string, (...args: any) => any>>(key: string): {
+    on: <T extends keyof TEvents>(event: T, listener: TEvents[T]) => void;
+    off: <T extends keyof TEvents>(event: T, listener: TEvents[T]) => void;
+};

package/dist/runtime/electron/createBroadcastHandlers.js

@@ -0,0 +1,30 @@
+import { ipcRenderer } from "electron";
+export function createBroadcastHandlers(key) {
+  const listeners = /* @__PURE__ */ new Map();
+  ipcRenderer.on(key, (_e, eventName, ...args) => {
+    const cbs = listeners.get(eventName);
+    if (cbs) {
+      for (const cb of cbs) {
+        cb(...args);
+      }
+    }
+  });
+  function on(event, listener) {
+    const cbs = listeners.get(event);
+    if (cbs) {
+      cbs.push(listener);
+    } else {
+      listeners.set(event, [listener]);
+    }
+  }
+  function off(event, listener) {
+    const cbs = listeners.get(event);
+    if (cbs) {
+      cbs.splice(cbs.indexOf(listener), 1);
+    }
+  }
+  return {
+    on,
+    off
+  };
+}

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

@@ -0,0 +1,2 @@
+import type { BrowserWindow } from "electron";
+export declare function createBroadcaster<TEvents extends Record<string, (...args: any) => any>>(key: string, getWindows: () => BrowserWindow[]): <T extends keyof TEvents>(event: T, ...args: Parameters<TEvents[T]>) => void;

package/dist/runtime/electron/createBroadcaster.js

@@ -0,0 +1,7 @@
+export function createBroadcaster(key, getWindows) {
+  return function broadcast(event, ...args) {
+    for (const win of getWindows()) {
+      win.webContents.send(key, event, ...args);
+    }
+  };
+}

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

@@ -0,0 +1,14 @@
+export declare function createNuxtFileProtocolHandler(session: Electron.Session, basePath: string, 
+/**
+ * If any route starts with one of these keys, it will get rerouted to the given value.
+ *
+ * At least `/api` should be added for a basic nuxt app to work correctly.
+ *
+ *
+ * ```ts
+ * routeProxies: {
+ * 	"/api": "http://localhost:3000/api",
+ * }
+ * ```
+ */
+routeProxies: Record<string, string>): void;

package/dist/runtime/electron/createNuxtFileProtocolHandler.js

@@ -0,0 +1,20 @@
+import { keys } from "@alanscodelog/utils/keys";
+import { net } from "electron";
+import path from "node:path";
+export function createNuxtFileProtocolHandler(session, basePath, routeProxies) {
+  const routeProxyKeys = keys(routeProxies);
+  session.protocol.handle("file", async (request) => {
+    const url = decodeURIComponent(request.url.slice(7));
+    const newUrl = path.isAbsolute(url) ? path.resolve(basePath, url.slice(1)) : path.resolve(basePath, url);
+    const proxyKey = routeProxyKeys.find((key) => url.startsWith(key));
+    if (proxyKey) {
+      const proxyUrl = routeProxies[proxyKey];
+      return net.fetch(proxyUrl + url);
+    }
+    const res = await net.fetch(`file://${newUrl}`, {
+      // avoid infinite loop
+      bypassCustomProtocolHandlers: true
+    }).catch((err) => new Response(err, { status: 404 }));
+    return res;
+  });
+}

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

@@ -0,0 +1,19 @@
+import type { IpcRenderer } from "electron";
+import type { WindowControlsApi } from "./types.js.js";
+/**
+ * Creates the apis to control the window from the preload script / client.
+ *
+ * ```ts
+ * // the default handler expects it to exist under `electron.api.ui.windowAction`
+ * // but you can configure it to use a different path
+ * constextBridge.exposeInMainWorld("electron", {
+ *		api: {
+ * 		ui: {
+ *				...createWindowControlsApi("windowAction")
+ * 		}
+ *		}
+ * })
+ * ```
+ */
+export declare function createWindowControlsApi(ipcRenderer: IpcRenderer, name: string): Record<string, WindowControlsApi>;
+export declare const windowControlsMessageKey = "window-control-action";

package/dist/runtime/electron/createWindowControlsApi.js

@@ -0,0 +1,6 @@
+import { promisifyApi } from "./promisifyApi.js";
+const key = "window-control-action";
+export function createWindowControlsApi(ipcRenderer, name) {
+  return promisifyApi(ipcRenderer, name, key);
+}
+export const windowControlsMessageKey = key;

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

@@ -0,0 +1,4 @@
+import type { BrowserWindow } from "electron";
+export declare function createWindowControlsApiHandler(
+/** Mostly for logging. Does not replace the action. */
+cb?: (win: BrowserWindow | undefined, action: "close" | "minimize" | "toggleMaximize" | "togglePin") => void): void;

package/dist/runtime/electron/createWindowControlsApiHandler.js

@@ -0,0 +1,24 @@
+import { windowControlsMessageKey } from "./createWindowControlsApi.js";
+import { promisifyReply } from "./promisifyReply.js";
+export function createWindowControlsApiHandler(cb) {
+  promisifyReply(windowControlsMessageKey, async (win, action) => {
+    switch (action) {
+      case "close":
+        win?.close();
+        break;
+      case "minimize":
+        win?.minimize();
+        break;
+      case "toggleMaximize":
+        console.log(win?.isMaximized());
+        win?.isMaximized() ? win?.unmaximize() : win?.maximize();
+        break;
+      case "togglePin":
+        win?.setAlwaysOnTop(!win?.isAlwaysOnTop());
+        break;
+      default:
+        throw new Error(`Invalid action: ${action}`);
+    }
+    cb?.(win, action);
+  });
+}

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

@@ -0,0 +1,11 @@
+import { BrowserWindow } from "electron";
+/**
+ * Gets the window that sent the event if it exists, otherwise tries to use the focused window.
+ *
+ * Set `defaultToFocused` to false to only use the sender window.
+ *
+ * Returns undefined if no window is found.
+ */
+export declare function getEventWindow(e: Electron.IpcMainEvent, { defaultToFocused }?: {
+    defaultToFocused?: boolean | undefined;
+}): BrowserWindow | undefined;

package/dist/runtime/electron/getEventWindow.js

@@ -0,0 +1,8 @@
+import { BrowserWindow } from "electron";
+export function getEventWindow(e, { defaultToFocused = true } = {}) {
+  const senderWindow = BrowserWindow.fromId(e.sender.id);
+  if (defaultToFocused) {
+    return senderWindow ?? BrowserWindow.getFocusedWindow() ?? void 0;
+  }
+  return senderWindow ?? void 0;
+}

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

@@ -0,0 +1,27 @@
+export declare function forceRelativePath(filepath: string): string;
+/**
+ * Calculates the correct paths for the app to run in electron.
+ *
+ * Note: For serverUrl to not be overridable in production, you should set `electron.additionalElectronVariables.publicServerUrl` to a quoted string.
+ *
+ * ```ts[nuxt.config.ts]
+ * export default defineNuxtConfig({
+ * 	modules: [
+ * 		"@witchcraft/nuxt-electron",
+ * 	],
+ * 	electron: {
+ * 		additionalElectronVariables: {
+ * 			publicServerUrl: process.env.NODE_ENV === "production"
+ * 			? `"mysite.com"`
+ * 			: `undefined`
+ * 		}
+ * 	}
+ * })
+ * ```
+ */
+export declare function getPaths(): {
+    windowUrl: string;
+    publicServerUrl: string;
+    nuxtPublicDir: string;
+    preloadPath: string;
+};

package/dist/runtime/electron/getPaths.js

@@ -0,0 +1,33 @@
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { app } from "electron";
+import path from "node:path";
+import { STATIC } from "./static.js";
+export function forceRelativePath(filepath) {
+  return path.join(`.${path.sep}`, filepath);
+}
+export function getPaths() {
+  const rootDir = app.getAppPath();
+  const nuxtPublicDir = path.resolve(rootDir, forceRelativePath(STATIC.ELECTRON_NUXT_PUBLIC_DIR));
+  const preloadPath = path.resolve(rootDir, forceRelativePath(STATIC.ELECTRON_BUILD_DIR), "./preload.cjs");
+  const base = {
+    nuxtPublicDir,
+    preloadPath,
+    publicServerUrl: process.env.PUBLIC_SERVER_URL ?? process.env.PUBLIC_SERVER_URL ?? process.env.VITE_DEV_SERVER_URL
+  };
+  if (!base.publicServerUrl) {
+    throw new Error("publicServerUrl could not be determined.");
+  }
+  if (process.env.VITE_DEV_SERVER_URL) {
+    return {
+      ...base,
+      windowUrl: `${process.env.VITE_DEV_SERVER_URL}${STATIC.ELECTRON_ROUTE}`
+    };
+  } else if (STATIC.ELECTRON_PROD_URL && STATIC.ELECTRON_BUILD_DIR) {
+    return {
+      ...base,
+      // careful, do not use path.join, it will remove extra slashes
+      windowUrl: `file://${STATIC.ELECTRON_PROD_URL}`
+    };
+  }
+  unreachable();
+}

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

@@ -0,0 +1,25 @@
+/**
+ * The preload script can be passed arguments using the `webPreferences.additionalArguments` option.
+ *
+ * ````ts [main.ts]
+ * const meta = { ... }
+ *
+ * const win = new BrowserWindow({
+ * 	webPreferences: {
+ * 		additionalArguments: [
+ * 			// you can change which key is used
+ * 			`--metadata=${JSON.stringify(meta)}`,
+ * 		],
+ * 	},
+ * })
+ * ```
+ *
+ * ````ts [preload.ts]
+ * const meta = getPreloadMeta<Meta>("metadata")
+ * ```
+ *
+ * This function can be used to get the metadata and type it in the preload script.
+ *
+ * Note that if it can't find the argument or there is an error parsing the json, it will throw.
+ */
+export declare function getPreloadMeta<T>(key: string): T;

package/dist/runtime/electron/getPreloadMeta.js

@@ -0,0 +1,7 @@
+export function getPreloadMeta(key) {
+  const meta = process.argv.find((arg) => arg.startsWith(`--${key}=`))?.split("=")?.[1];
+  if (!meta) {
+    throw new Error("No metadata passed to renderer.");
+  }
+  return JSON.parse(meta);
+}

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

@@ -0,0 +1,16 @@
+export * from "./types.js";
+export { getPaths } from "./getPaths.js";
+export { createNuxtFileProtocolHandler } from "./createNuxtFileProtocolHandler.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 { promisifyReply } from "./promisifyReply.js";
+export { createBroadcaster } from "./createBroadcaster.js";
+export { createBroadcastHandlers } from "./createBroadcastHandlers.js";

package/dist/runtime/electron/index.js

@@ -0,0 +1,16 @@
+export * from "./types.js";
+export { getPaths } from "./getPaths.js";
+export { createNuxtFileProtocolHandler } from "./createNuxtFileProtocolHandler.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 { promisifyReply } from "./promisifyReply.js";
+export { createBroadcaster } from "./createBroadcaster.js";
+export { createBroadcastHandlers } from "./createBroadcastHandlers.js";

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

@@ -0,0 +1,40 @@
+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]
+ * export type ElectronApi = {
+ * 	api: {
+ * 		someApi: (apiParam: string, apiParam2: number) => Promise<void>
+ * 	}
+ * }
+ * ```
+ * ```ts [preload.ts]
+ * contextBridge.exposeInMainWorld("electron", {
+ * 	api: {
+ * 		...promisifyApi<"someApi", ElectronApi["api"]["someApi"]>(ipcRenderer, "someApi", MESSAGE.UNIQUE_KEY),
+ * 	},
+ * })
+ * ```
+ *
+ * ```ts [main.ts]
+ * import { promisifyReply } from "@witchcraft/nuxt-electron/runtime/electron"
+ * promisifyReply<
+ * 	ElectronApi["api"]["someApi"]
+ * >(ipcRenderer, MESSAGE.UNIQUE_KEY, (win, apiParam, apiParam2) => {
+ * 	// this doesn't have to be async, though on the client side,
+ * 	// it will always be async
+ * 	return electronSideOfApi(apiParam, apiParam2)
+ * })
+ * ```
+ *
+ * ```ts [renderer.ts]
+ * const result = await electron.api.someApi(apiParam, apiParam2)
+ * ```
+ *
+ * By default, calls will timeout and reject after 10 seconds. This can be changed by changing the timeout option.
+ */
+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;
+    timeout?: number;
+}): Record<TKey, TFunction>;

package/dist/runtime/electron/promisifyApi.js

@@ -0,0 +1,41 @@
+const promiseResolveMap = /* @__PURE__ */ new Map();
+export function promisifyApi(ipcRenderer, key, messageKey, modifyArgs, { debug, timeout } = { debug: true, timeout: 1e4 }) {
+  return {
+    [key]: async (...args) => new Promise((resolve, reject) => {
+      const promiseId = crypto.randomUUID();
+      promiseResolveMap.set(promiseId, { resolve, reject });
+      if (modifyArgs) {
+        args = modifyArgs(args);
+      }
+      if (debug) {
+        console.log("promisifyApi:sent", messageKey, promiseId, args);
+      }
+      const timer = setTimeout(() => {
+        const resolver = promiseResolveMap.get(promiseId);
+        if (resolver) {
+          promiseResolveMap.delete(promiseId);
+          ipcRenderer.off(messageKey, listener);
+          resolver.reject(new Error(`promisifyApi: Timeout for ${messageKey}`));
+        }
+      }, timeout);
+      function listener(_event, resPromiseId, res, info) {
+        if (debug) {
+          console.log("promiseApi:received", resPromiseId, res);
+        }
+        const resolver = promiseResolveMap.get(resPromiseId);
+        if (resolver) {
+          clearTimeout(timer);
+          promiseResolveMap.delete(resPromiseId);
+          ipcRenderer.off(messageKey, listener);
+          if (info?.isError) {
+            resolver.reject(res);
+          } else {
+            resolver.resolve(res);
+          }
+        }
+      }
+      ipcRenderer.on(messageKey, listener);
+      ipcRenderer.send(messageKey, promiseId, ...args);
+    })
+  };
+}

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

@@ -0,0 +1,8 @@
+import { type BrowserWindow } from "electron";
+/** See {@link promisifyApi} for more info. */
+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 }?: {
+    defaultToFocused?: boolean;
+    debug?: boolean;
+}): void;

package/dist/runtime/electron/promisifyReply.js

@@ -0,0 +1,27 @@
+import { ipcMain } from "electron";
+import { getEventWindow } from "./getEventWindow.js";
+export function promisifyReply(key, cb, {
+  defaultToFocused = true,
+  debug = false
+} = {}) {
+  ipcMain.on(key, (e, promiseId, ...args) => {
+    const win = getEventWindow(e, { defaultToFocused });
+    if (!win) {
+      throw new Error("No window to send reply to.");
+    }
+    if (debug) {
+      console.log({ key, promiseId, args });
+    }
+    const res = cb(win, ...args);
+    if (res instanceof Promise) {
+      res.then((innerRes) => {
+        win.webContents.send(key, promiseId, innerRes);
+      }).catch((err) => {
+        console.error(err, { key, promiseId, args });
+        win.webContents.send(key, promiseId, err, { isError: true });
+      });
+    } else {
+      win.webContents.send(key, promiseId, res);
+    }
+  });
+}

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

@@ -0,0 +1,2 @@
+/** Registers F12 and Ctrl+Shift+I as shortcuts to open the devtools. */
+export declare function registerDevtoolsShortcuts(win: Electron.BrowserWindow): void;

package/dist/runtime/electron/registerDevtoolsShortcuts.js

@@ -0,0 +1,10 @@
+export function registerDevtoolsShortcuts(win) {
+  win.webContents.on("before-input-event", (event, input) => {
+    if (input.type === "keyDown") {
+      if (input.shift && input.control && input.key.toLowerCase() === "i" || input.key === "F12") {
+        win.webContents.openDevTools();
+        event.preventDefault();
+      }
+    }
+  });
+}

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

@@ -0,0 +1,12 @@
+import type { PublicRuntimeConfig } from "nuxt/schema";
+/**
+ * Group of the module's vite's injected variables.
+ */
+export declare const STATIC: {
+    ELECTRON_ROUTE: string;
+    ELECTRON_PROD_URL: string;
+    ELECTRON_NUXT_DIR: string;
+    ELECTRON_NUXT_PUBLIC_DIR: string;
+    ELECTRON_BUILD_DIR: string;
+    ELECTRON_RUNTIME_CONFIG: PublicRuntimeConfig;
+};

package/dist/runtime/electron/static.js

@@ -0,0 +1,8 @@
+export const STATIC = {
+  ELECTRON_ROUTE: process.env.ELECTRON_ROUTE,
+  ELECTRON_PROD_URL: process.env.ELECTRON_PROD_URL,
+  ELECTRON_NUXT_DIR: process.env.ELECTRON_NUXT_DIR,
+  ELECTRON_NUXT_PUBLIC_DIR: process.env.ELECTRON_NUXT_PUBLIC_DIR,
+  ELECTRON_BUILD_DIR: process.env.ELECTRON_BUILD_DIR,
+  ELECTRON_RUNTIME_CONFIG: process.env.ELECTRON_RUNTIME_CONFIG ? JSON.parse(process.env.ELECTRON_RUNTIME_CONFIG) : void 0
+};

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

@@ -0,0 +1 @@
+export type WindowControlsApi = (action: "close" | "minimize" | "toggleMaximize" | "togglePin") => Promise<void>;

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

@@ -0,0 +1 @@
+export declare function useDevDataDir(): string | undefined;