@reause/electron 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hairyf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,315 @@
+import { RefOrValue } from "@reause/shared";
+import { IpcRenderer, IpcRendererEvent, WebFrame } from "electron";
+//#region _types.d.ts
+/**
+ * An `ipcRenderer` message listener — `listener(event, ...args)`.
+ *
+ * Mirrors upstream `source/vueuse/packages/electron/_types.ts`.
+ */
+type IpcRendererListener = (event: IpcRendererEvent, ...args: any[]) => void;
+//#endregion
+//#region useIpcRenderer/index.d.ts
+/**
+ * Result from useIpcRenderer
+ *
+ * @see https://www.electronjs.org/docs/api/ipc-renderer
+ */
+export interface UseIpcRendererReturn {
+  /**
+   * Listens to channel, when a new message arrives listener would be called with listener(event, args...).
+   * [ipcRenderer.removeListener](https://www.electronjs.org/docs/api/ipc-renderer#ipcrendererremovelistenerchannel-listener) automatically on unmounted.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendereronchannel-listener
+   */
+  on: (channel: string, listener: IpcRendererListener) => IpcRenderer;
+  /**
+   * Adds a one time listener function for the event. This listener is invoked only the next time a message is sent to channel, after which it is removed.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendereroncechannel-listener
+   */
+  once: (channel: string, listener: (event: IpcRendererEvent, ...args: any[]) => void) => IpcRenderer;
+  /**
+   * Removes the specified listener from the listener array for the specified channel.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendererremovelistenerchannel-listener
+   */
+  removeListener: (channel: string, listener: (...args: any[]) => void) => IpcRenderer;
+  /**
+   * Removes all listeners, or those of the specified channel.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendererremovealllistenerschannel
+   */
+  removeAllListeners: (channel: string) => IpcRenderer;
+  /**
+   * Send an asynchronous message to the main process via channel, along with arguments.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrenderersendchannel-args
+   */
+  send: (channel: string, ...args: any[]) => void;
+  /**
+   * Returns `Promise<any>` — resolves with the response from the main process.
+   * Send a message to the main process via channel and expect a result ~~asynchronously~~.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendererinvokechannel-args
+   */
+  invoke: <T>(channel: string, ...args: any[]) => Promise<T>;
+  /**
+   * Returns `any` — the value sent back by the `ipcMain` handler.
+   * Send a message to the main process via channel and expect a result synchronously.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrenderersendsyncchannel-args
+   */
+  sendSync: <T>(channel: string, ...args: any[]) => T;
+  /**
+   * Send a message to the main process, optionally transferring ownership of zero or more MessagePort objects.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendererpostmessagechannel-message-transfer
+   */
+  postMessage: (channel: string, message: any, transfer?: MessagePort[]) => void;
+  /**
+   * Sends a message to a window with webContentsId via channel.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrenderersendtowebcontentsid-channel-args
+   */
+  sendTo: (webContentsId: number, channel: string, ...args: any[]) => void;
+  /**
+   * Like `ipcRenderer.send` but the event will be sent to the `<webview>` element in the host page instead of the main process.
+   *
+   * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrenderersendtohostchannel-args
+   */
+  sendToHost: (channel: string, ...args: any[]) => void;
+}
+/**
+ * Get the `ipcRenderer` module with all APIs.
+ *
+ * Map from @vueuse/electron `useIpcRenderer`
+ * (`source/vueuse/packages/electron/useIpcRenderer/`).
+ *
+ * React deviations:
+ * - upstream implements `on` by calling the `useIpcRendererOn` composable
+ *   inside the method. Hooks cannot be called from callbacks, so `on`
+ *   registers directly and tracks `{ ipc, channel, listener }` pairs; a mount
+ *   effect's cleanup removes every tracked listener from **its captured
+ *   instance** on unmount (the same auto-cleanup guarantee upstream gets from
+ *   the effect scope). Like upstream, listeners are not re-registered when the
+ *   instance changes — each stays on the instance it was registered with;
+ * - upstream `invoke` returns a `ShallowRef<T | null>`; this port returns the
+ *   raw `Promise<T>`. Declarative async state is the job of the
+ *   `useIpcRendererInvoke` hook — a method on a returned object cannot own
+ *   component state;
+ * - upstream `sendSync` wraps the synchronous return in a `ShallowRef`; this
+ *   port returns the value `T` directly.
+ *
+ * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrenderersendtohostchannel-args
+ * @see https://vueuse.org/useIpcRenderer
+ *
+ * @example
+ * const ipcRenderer = useIpcRenderer()
+ * ipcRenderer.on('custom-event', (event, ...args) => console.log(args))
+ * const result = await ipcRenderer.invoke<string>('custom-channel', 'some data')
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useIpcRenderer(ipcRenderer?: IpcRenderer): UseIpcRendererReturn;
+//#endregion
+//#region useIpcRendererInvoke/index.d.ts
+/**
+ * Returns `T | null` — the response from the main process once the
+ * asynchronous `invoke` call resolves.
+ *
+ * Send a message to the main process via channel and expect a result asynchronously.
+ *
+ * You need to provide `ipcRenderer` to this function.
+ *
+ * Map from @vueuse/electron `useIpcRendererInvoke`
+ * (`source/vueuse/packages/electron/useIpcRendererInvoke/`).
+ *
+ * React deviations:
+ * - upstream returns a `ShallowRef<T | null>`; a React hook cannot return a Vue
+ *   ref, so this port returns the plain value `T | null` (same non-tuple
+ *   precedent as `useQRCode`'s plain `string`);
+ * - the invoke runs in an effect, so changing `channel` / `args` re-invokes
+ *   (upstream runs once per setup). The result is unmount-safe: a late
+ *   resolution after unmount does not update state;
+ * - upstream leaves rejections unhandled and so does this port (no `.catch`).
+ *   Callers that need error handling should call `ipcRenderer.invoke` directly,
+ *   or use `useIpcRenderer().invoke`, which returns the raw `Promise<T>`.
+ *
+ * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendererinvokechannel-args
+ * @see https://vueuse.org/useIpcRendererInvoke
+ *
+ * @example
+ * const result = useIpcRendererInvoke<string>('custom-channel', 'some data')
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useIpcRendererInvoke<T>(ipcRenderer: IpcRenderer, channel: string, ...args: any[]): T | null;
+/**
+ * Returns `T | null` — the response from the main process once the
+ * asynchronous `invoke` call resolves.
+ *
+ * Send a message to the main process via channel and expect a result asynchronously.
+ *
+ * `ipcRenderer` will be automatically gotten (`window.require('electron')`, i.e. `nodeIntegration`).
+ *
+ * Map from @vueuse/electron `useIpcRendererInvoke`
+ * (`source/vueuse/packages/electron/useIpcRendererInvoke/`).
+ *
+ * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendererinvokechannel-args
+ * @see https://vueuse.org/useIpcRendererInvoke
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useIpcRendererInvoke<T>(channel: string, ...args: any[]): T | null;
+//#endregion
+//#region useIpcRendererOn/index.d.ts
+/**
+ * Listens to channel, when a new message arrives listener would be called with `listener(event, args...)`.
+ * [`ipcRenderer.removeListener`](https://www.electronjs.org/docs/api/ipc-renderer#ipcrendererremovelistenerchannel-listener) automatically on unmounted.
+ *
+ * You need to provide `ipcRenderer` to this function.
+ *
+ * Map from @vueuse/electron `useIpcRendererOn`
+ * (`source/vueuse/packages/electron/useIpcRendererOn/`).
+ *
+ * React deviations:
+ * - upstream registers the listener at setup and removes it in
+ *   `tryOnScopeDispose`; here a mount effect registers the **actual**
+ *   `listener` you passed (no wrapper) and removes it by the same identity on
+ *   unmount, so `removeListener(channel, listener)` always matches;
+ * - because `listener` is an effect dependency, a new listener identity
+ *   re-registers (remove + add). Stabilise it with `useCallback`, or use the
+ *   `useListener` protocol where it fits;
+ * - the instance is resolved at render, so a missing `ipcRenderer` throws
+ *   synchronously instead of at effect time.
+ *
+ * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendereronchannel-listener
+ * @see https://vueuse.org/useIpcRendererOn
+ *
+ * @example
+ * useIpcRendererOn('custom-event', (event, ...args) => {
+ *   console.log(args)
+ * })
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useIpcRendererOn(ipcRenderer: IpcRenderer, channel: string, listener: IpcRendererListener): IpcRenderer;
+/**
+ * Listens to channel, when a new message arrives listener would be called with `listener(event, args...)`.
+ * [`ipcRenderer.removeListener`](https://www.electronjs.org/docs/api/ipc-renderer#ipcrendererremovelistenerchannel-listener) automatically on unmounted.
+ *
+ * `ipcRenderer` will be automatically gotten (`window.require('electron')`, i.e. `nodeIntegration`).
+ *
+ * Map from @vueuse/electron `useIpcRendererOn`
+ * (`source/vueuse/packages/electron/useIpcRendererOn/`).
+ *
+ * @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrendereronchannel-listener
+ * @see https://vueuse.org/useIpcRendererOn
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useIpcRendererOn(channel: string, listener: IpcRendererListener): IpcRenderer;
+//#endregion
+//#region useZoomFactor/index.d.ts
+/**
+ * Setter returned by `useZoomFactor`: validates the factor, writes it to
+ * `WebFrame.setZoomFactor` and updates the value returned by the hook.
+ */
+export type ZoomFactorSetter = (value: number) => void;
+/**
+ * Reactive `WebFrame` zoom factor — React port of VueUse's `useZoomFactor`.
+ *
+ * Map from @vueuse/electron `useZoomFactor`
+ * (`source/vueuse/packages/electron/useZoomFactor/`). Upstream returns a
+ * writable Vue `Ref<number>` whose setter writes to
+ * `WebFrame.setZoomFactor`; this port follows the repo's state-like writable
+ * rule and returns the React tuple `[factor, setFactor]` instead.
+ *
+ * Adjustment for React:
+ * - the writable ref becomes `const [factor, setFactor] = useZoomFactor()` —
+ *   `setFactor(value)` validates the value, calls
+ *   `webFrame.setZoomFactor(value)` and updates the returned factor;
+ * - upstream's `watch(factor, cb, { immediate: true })` maps to a single
+ *   effect keyed on `[webFrame, external factor]`: because the last-written ref
+ *   starts as `null`, the immediate run is covered by the first effect run,
+ *   which applies an explicitly passed factor once on mount and re-applies
+ *   whenever the source value changes. The last factor written to `webFrame`
+ *   is tracked in a ref, so a redundant render never re-writes the same
+ *   factor;
+ * - upstream's `0` guard is kept verbatim — `useZoomFactor(webFrame, 0)` and
+ *   `setFactor(0)` both throw `the factor must be greater than 0.0.`;
+ * - the `WebFrame` instance is resolved once per render through the internal
+ *   `resolveWebFrame` helper: pass it explicitly, or enable `nodeIntegration`
+ *   so it can be read from `window.require('electron').webFrame`;
+ * - `useZoomFactor()` reads the current factor from `getZoomFactor()`, while
+ *   `useZoomFactor(2)` / `useZoomFactor(webFrame, 2)` apply the factor given
+ *   as a plain number or a React ref.
+ *
+ * @see https://www.electronjs.org/docs/api/web-frame#webframesetzoomfactorfactor
+ * @see https://vueuse.org/useZoomFactor
+ *
+ * @example
+ * const [factor, setFactor] = useZoomFactor()
+ * console.log(factor) // current zoom factor
+ * setFactor(2) // webFrame.setZoomFactor(2)
+ *
+ * @example
+ * const [factor] = useZoomFactor(webFrame, 2) // apply an explicit factor on mount
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useZoomFactor(factor?: RefOrValue<number>): [number, ZoomFactorSetter];
+export declare function useZoomFactor(webFrame: WebFrame, factor?: RefOrValue<number>): [number, ZoomFactorSetter];
+//#endregion
+//#region useZoomLevel/index.d.ts
+/**
+ * Setter returned by `useZoomLevel`: writes the level to
+ * `WebFrame.setZoomLevel` and updates the value returned by the hook.
+ */
+export type ZoomLevelSetter = (value: number) => void;
+/**
+ * Reactive `WebFrame` zoom level — React port of VueUse's `useZoomLevel`.
+ *
+ * Map from @vueuse/electron `useZoomLevel`
+ * (`source/vueuse/packages/electron/useZoomLevel/`). Upstream returns a
+ * writable Vue `Ref<number>` whose setter writes to `WebFrame.setZoomLevel`;
+ * this port follows the repo's state-like writable rule and returns the React
+ * tuple `[level, setLevel]` instead.
+ *
+ * Adjustment for React:
+ * - the writable ref becomes `const [level, setLevel] = useZoomLevel()` —
+ *   `setLevel(value)` calls `webFrame.setZoomLevel(value)` and updates the
+ *   returned level;
+ * - upstream's `watch(level, cb, { immediate: true })` maps to a single sync
+ *   effect keyed on `[webFrame, external level]` whose first run applies an
+ *   explicitly passed level (upstream's immediate run) and re-applies when
+ *   the source value changes. The last level written to `webFrame` is tracked
+ *   in a ref, so a redundant render never re-writes the same level;
+ * - a ref-like level source stays the single source of truth (upstream's
+ *   `deepRef` passthrough): `setLevel` writes back to `ref.current`, so later
+ *   renders re-read the updated value instead of a stale one;
+ * - upstream has no range guard for zoom levels, so neither has this port —
+ *   `0` is a valid level (upstream's `useZoomFactor` guard does not apply);
+ * - the `WebFrame` instance is resolved once per render through the internal
+ *   `resolveWebFrame` helper: pass it explicitly, or enable `nodeIntegration`
+ *   so it can be read from `window.require('electron').webFrame`;
+ * - `useZoomLevel()` reads the current level from `getZoomLevel()`, while
+ *   `useZoomLevel(2)` / `useZoomLevel(webFrame, 2)` apply the level given as a
+ *   plain number or a React ref.
+ *
+ * @see https://www.electronjs.org/docs/api/web-frame#webframesetzoomlevellevel
+ * @see https://vueuse.org/useZoomLevel
+ *
+ * @example
+ * const [level, setLevel] = useZoomLevel()
+ * console.log(level) // current zoom level
+ * setLevel(2) // webFrame.setZoomLevel(2)
+ *
+ * @example
+ * const [level] = useZoomLevel(webFrame, 2) // apply an explicit level on mount
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useZoomLevel(level?: RefOrValue<number>): [number, ZoomLevelSetter];
+export declare function useZoomLevel(webFrame: WebFrame, level?: RefOrValue<number>): [number, ZoomLevelSetter];
+//#endregion

package/dist/index.js

@@ -0,0 +1,206 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { isRefLike, toValue } from "@reause/shared";
+//#region _resolve/index.tsx
+/**
+* Resolve an `ipcRenderer` instance from the explicit argument or, when
+* `nodeIntegration` is enabled, from `window.require('electron')`.
+*
+* Internal helper (not exported from `index.ts`). Resolution happens at
+* render time — not inside an effect — so a missing instance throws
+* synchronously, exactly like upstream.
+*
+* Each caller passes its own upstream-verbatim error message, because
+* upstream `useIpcRenderer` and the `useIpcRendererInvoke` /
+* `useIpcRendererOn` pair word it differently.
+*/
+function resolveIpcRenderer(ipcRenderer, message = "provide IpcRenderer module or enable nodeIntegration") {
+	var _require;
+	if (ipcRenderer) return ipcRenderer;
+	const resolved = typeof window !== "undefined" && typeof window.require === "function" ? (_require = window.require("electron")) === null || _require === void 0 ? void 0 : _require.ipcRenderer : void 0;
+	if (!resolved) throw new Error(message);
+	return resolved;
+}
+/**
+* Resolve a `webFrame` instance from the explicit argument or, when
+* `nodeIntegration` is enabled, from `window.require('electron')`.
+*
+* Internal helper (not exported from `index.ts`), reserved for the zoom
+* hooks (`useZoomFactor` / `useZoomLevel`, #256 / #257).
+*/
+function resolveWebFrame(webFrame, message = "provide WebFrame module or enable nodeIntegration") {
+	var _require2;
+	if (webFrame) return webFrame;
+	const resolved = typeof window !== "undefined" && typeof window.require === "function" ? (_require2 = window.require("electron")) === null || _require2 === void 0 ? void 0 : _require2.webFrame : void 0;
+	if (!resolved) throw new Error(message);
+	return resolved;
+}
+//#endregion
+//#region useIpcRenderer/index.tsx
+/**
+* Get the `ipcRenderer` module with all APIs.
+*
+* Map from @vueuse/electron `useIpcRenderer`
+* (`source/vueuse/packages/electron/useIpcRenderer/`).
+*
+* React deviations:
+* - upstream implements `on` by calling the `useIpcRendererOn` composable
+*   inside the method. Hooks cannot be called from callbacks, so `on`
+*   registers directly and tracks `{ ipc, channel, listener }` pairs; a mount
+*   effect's cleanup removes every tracked listener from **its captured
+*   instance** on unmount (the same auto-cleanup guarantee upstream gets from
+*   the effect scope). Like upstream, listeners are not re-registered when the
+*   instance changes — each stays on the instance it was registered with;
+* - upstream `invoke` returns a `ShallowRef<T | null>`; this port returns the
+*   raw `Promise<T>`. Declarative async state is the job of the
+*   `useIpcRendererInvoke` hook — a method on a returned object cannot own
+*   component state;
+* - upstream `sendSync` wraps the synchronous return in a `ShallowRef`; this
+*   port returns the value `T` directly.
+*
+* @see https://www.electronjs.org/docs/api/ipc-renderer#ipcrenderersendtohostchannel-args
+* @see https://vueuse.org/useIpcRenderer
+*
+* @example
+* const ipcRenderer = useIpcRenderer()
+* ipcRenderer.on('custom-event', (event, ...args) => console.log(args))
+* const result = await ipcRenderer.invoke<string>('custom-channel', 'some data')
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useIpcRenderer(ipcRenderer) {
+	const resolved = resolveIpcRenderer(ipcRenderer);
+	const trackedRef = useRef([]);
+	useEffect(() => {
+		return () => {
+			trackedRef.current.forEach(({ ipc, channel, listener }) => {
+				ipc.removeListener(channel, listener);
+			});
+			trackedRef.current = [];
+		};
+	}, []);
+	return {
+		on: (channel, listener) => {
+			resolved.on(channel, listener);
+			trackedRef.current.push({
+				ipc: resolved,
+				channel,
+				listener
+			});
+			return resolved;
+		},
+		once: resolved.once.bind(resolved),
+		removeListener: resolved.removeListener.bind(resolved),
+		removeAllListeners: resolved.removeAllListeners.bind(resolved),
+		send: resolved.send,
+		invoke: (channel, ...args) => resolved.invoke(channel, ...args),
+		sendSync: (channel, ...args) => resolved.sendSync(channel, ...args),
+		postMessage: resolved.postMessage,
+		sendTo: resolved.sendTo,
+		sendToHost: resolved.sendToHost
+	};
+}
+//#endregion
+//#region useIpcRendererInvoke/index.tsx
+function useIpcRendererInvoke(...args) {
+	let ipcRenderer;
+	let channel;
+	let invokeArgs;
+	if (typeof args[0] === "string") [channel, ...invokeArgs] = args;
+	else [ipcRenderer, channel, ...invokeArgs] = args;
+	const resolved = resolveIpcRenderer(ipcRenderer, "please provide IpcRenderer module or enable nodeIntegration");
+	const [result, setResult] = useState(null);
+	const effectDeps = [
+		resolved,
+		channel,
+		...invokeArgs
+	];
+	useEffect(() => {
+		let cancelled = false;
+		resolved.invoke(channel, ...invokeArgs).then((response) => {
+			if (!cancelled) setResult(response);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, effectDeps);
+	return result;
+}
+//#endregion
+//#region useIpcRendererOn/index.tsx
+function useIpcRendererOn(...args) {
+	let ipcRenderer;
+	let channel;
+	let listener;
+	if (typeof args[0] === "string") [channel, listener] = args;
+	else [ipcRenderer, channel, listener] = args;
+	const resolved = resolveIpcRenderer(ipcRenderer, "please provide IpcRenderer module or enable nodeIntegration");
+	useEffect(() => {
+		resolved.on(channel, listener);
+		return () => {
+			resolved.removeListener(channel, listener);
+		};
+	}, [
+		resolved,
+		channel,
+		listener
+	]);
+	return resolved;
+}
+//#endregion
+//#region useZoomFactor/index.tsx
+const ZOOM_FACTOR_ERROR = "the factor must be greater than 0.0.";
+function assertZoomFactor(value) {
+	if (value === 0) throw new Error(ZOOM_FACTOR_ERROR);
+}
+function isFactorArgument(value) {
+	return typeof value === "number" || isRefLike(value);
+}
+function useZoomFactor(webFrameOrFactor, factor) {
+	const webFrame = isFactorArgument(webFrameOrFactor) ? void 0 : webFrameOrFactor;
+	const externalFactor = isFactorArgument(webFrameOrFactor) ? webFrameOrFactor : factor;
+	const instance = resolveWebFrame(webFrame);
+	const resolvedFactor = externalFactor === void 0 ? void 0 : toValue(externalFactor);
+	if (resolvedFactor !== void 0) assertZoomFactor(resolvedFactor);
+	const [value, setValue] = useState(() => resolvedFactor === void 0 ? instance.getZoomFactor() : resolvedFactor);
+	const lastAppliedRef = useRef(null);
+	useEffect(() => {
+		if (resolvedFactor === void 0 || resolvedFactor === lastAppliedRef.current) return;
+		assertZoomFactor(resolvedFactor);
+		instance.setZoomFactor(resolvedFactor);
+		lastAppliedRef.current = resolvedFactor;
+		setValue(resolvedFactor);
+	}, [instance, resolvedFactor]);
+	return [value, useCallback((nextFactor) => {
+		assertZoomFactor(nextFactor);
+		instance.setZoomFactor(nextFactor);
+		lastAppliedRef.current = nextFactor;
+		setValue(nextFactor);
+	}, [instance])];
+}
+//#endregion
+//#region useZoomLevel/index.tsx
+function isLevelArgument(value) {
+	return typeof value === "number" || isRefLike(value);
+}
+function useZoomLevel(webFrameOrLevel, level) {
+	const webFrame = isLevelArgument(webFrameOrLevel) ? void 0 : webFrameOrLevel;
+	const externalLevel = isLevelArgument(webFrameOrLevel) ? webFrameOrLevel : level;
+	const instance = resolveWebFrame(webFrame);
+	const resolvedLevel = externalLevel === void 0 ? void 0 : toValue(externalLevel);
+	const [value, setValue] = useState(() => resolvedLevel === void 0 ? instance.getZoomLevel() : resolvedLevel);
+	const lastAppliedRef = useRef(null);
+	useEffect(() => {
+		if (resolvedLevel === void 0 || resolvedLevel === lastAppliedRef.current) return;
+		instance.setZoomLevel(resolvedLevel);
+		lastAppliedRef.current = resolvedLevel;
+		setValue(resolvedLevel);
+	}, [instance, resolvedLevel]);
+	return [value, useCallback((nextLevel) => {
+		instance.setZoomLevel(nextLevel);
+		lastAppliedRef.current = nextLevel;
+		setValue(nextLevel);
+		if (isRefLike(externalLevel)) externalLevel.current = nextLevel;
+	}, [instance, externalLevel])];
+}
+//#endregion
+export { useIpcRenderer, useIpcRendererInvoke, useIpcRendererOn, useZoomFactor, useZoomLevel };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@reause/electron",
+  "type": "module",
+  "version": "0.1.2",
+  "description": "Electron renderer process modules — React port of @vueuse/electron",
+  "license": "MIT",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "electron": ">=9.0.0",
+    "react": ">=18"
+  },
+  "dependencies": {
+    "@reause/shared": "0.1.2"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}