electron-incremental-update 2.4.3 → 3.0.0-beta.3

package/dist/index.mjs

@@ -0,0 +1,273 @@
+import { a as getPathFromAppNameAsar, f as isDev, i as getEntryVersion, r as getAppVersion, y as restartApp } from "./electron-OKQIYbcw.mjs";
+import { r as isUpdateJSON } from "./version--eVB2A7n.mjs";
+import { BrowserWindow, app } from "electron";
+import fs from "node:fs";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+
+//#region src/entry/types.ts
+var UpdaterError = class extends Error {
+	code;
+	constructor(code, info) {
+		super(`[${code}] ${info}`);
+		this.code = code;
+	}
+};
+
+//#endregion
+//#region src/entry/updater.ts
+var Updater = class extends EventEmitter {
+	CERT;
+	controller;
+	info;
+	tmpFilePath;
+	processing = false;
+	provider;
+	/**
+	* Updater logger
+	*/
+	logger;
+	/**
+	* Whether to receive beta update
+	*/
+	receiveBeta;
+	/**
+	* Whether force update in DEV
+	*/
+	forceUpdate;
+	/**
+	* Initialize incremental updater
+	* @param options UpdaterOption
+	*/
+	constructor(options = {}) {
+		super();
+		this.provider = options.provider;
+		this.receiveBeta = options.receiveBeta;
+		this.CERT = options.SIGNATURE_CERT || __EIU_SIGNATURE_CERT__;
+		this.logger = options.logger;
+		this.controller = new AbortController();
+		if (isDev && !this.logger) {
+			this.logger = {
+				info: (...args) => console.log("[EIU-INFO ]", ...args),
+				debug: (...args) => console.log("[EIU-DEBUG]", ...args),
+				warn: (...args) => console.log("[EIU-WARN ]", ...args),
+				error: (...args) => console.error("[EIU-ERROR]", ...args)
+			};
+			this.logger.info("No logger set, enable dev-only logger");
+		}
+		if (!this.provider) this.logger?.debug("WARN: No update provider");
+	}
+	async fetch(format, data) {
+		if (typeof data === "object") if (format === "json" && isUpdateJSON(data) || format === "buffer" && Buffer.isBuffer(data)) return data;
+		else {
+			this.err("Invalid type", "ERR_PARAM", `Invalid type at format '${format}': ${JSON.stringify(data)}`);
+			return;
+		}
+		this.logger?.debug(`Download from \`${this.provider.name}\``);
+		try {
+			const result = format === "json" ? await this.provider.downloadJSON(app.name, __EIU_VERSION_PATH__, this.controller.signal) : await this.provider.downloadAsar(this.info, this.controller.signal, (info) => this.emit("download-progress", info));
+			this.logger?.debug(`Download ${format} success${format === "buffer" ? `, file size: ${result.length}` : ""}`);
+			return result;
+		} catch (e) {
+			this.err(`Fetch ${format} failed`, "ERR_NETWORK", e instanceof Error ? e.message : e.toString());
+		}
+	}
+	cleanup() {
+		if (this.tmpFilePath && fs.existsSync(this.tmpFilePath)) try {
+			fs.unlinkSync(this.tmpFilePath);
+			this.tmpFilePath = void 0;
+			this.logger?.debug("Cleaned up temporary update file");
+		} catch (error) {
+			this.logger?.warn(`Failed to clean up temporary update file: ${error}`);
+		}
+	}
+	/**
+	* Handle error message and emit error event
+	*/
+	err(msg, code, errorInfo) {
+		const err = new UpdaterError(code, errorInfo);
+		this.logger?.error(`[${code}] ${msg}`, err);
+		this.cleanup();
+		this.emit("error", err);
+	}
+	async checkForUpdates(data) {
+		const emitUnavailable = (msg, code, info) => {
+			this.logger?.info(`[${code}] ${msg}`);
+			this.logger?.debug("Check update end");
+			this.processing = false;
+			this.emit("update-not-available", code, msg, info);
+			return false;
+		};
+		if (this.processing) {
+			this.logger?.info("Updater is already processing, skip check update");
+			return false;
+		}
+		this.processing = true;
+		this.logger?.debug("Check update start");
+		if (!data && !this.provider) {
+			const msg = "No update json or provider";
+			this.err("Check update failed", "ERR_PARAM", msg);
+			return emitUnavailable(msg, "UNAVAILABLE_ERROR");
+		}
+		const _data = await this.fetch("json", data);
+		if (!_data) return emitUnavailable("Failed to get update info", "UNAVAILABLE_ERROR");
+		const { signature, version, minimumVersion, url, ...rest } = this.receiveBeta ? _data.beta : _data;
+		const info = {
+			signature,
+			minimumVersion,
+			version,
+			url
+		};
+		const extraVersionInfo = {
+			signature,
+			minimumVersion,
+			version,
+			appVersion: getAppVersion(),
+			entryVersion: getEntryVersion(),
+			...rest
+		};
+		this.logger?.debug(`Checked update, version: ${version}, signature: ${signature}`);
+		if (isDev && !this.forceUpdate && !data) return emitUnavailable("Skip check update in dev mode. To force update, set `updater.forceUpdate` to true or call checkUpdate with UpdateJSON", "UNAVAILABLE_DEV");
+		const isLowerVersion = this.provider.isLowerVersion;
+		try {
+			if (isLowerVersion(extraVersionInfo.entryVersion, minimumVersion)) return emitUnavailable(`Entry Version (${extraVersionInfo.entryVersion}) < MinimumVersion (${minimumVersion})`, "UNAVAILABLE_VERSION", extraVersionInfo);
+			this.logger?.info(`Current version is ${extraVersionInfo.appVersion}, new version is ${version}`);
+			if (!isLowerVersion(extraVersionInfo.appVersion, version)) return emitUnavailable(`Current version (${extraVersionInfo.appVersion}) > New version (${version})`, "UNAVAILABLE_VERSION", extraVersionInfo);
+			this.logger?.info(`Update available: ${version}`);
+			this.info = info;
+			this.processing = false;
+			this.logger?.debug("Check update end");
+			this.emit("update-available", extraVersionInfo);
+			return true;
+		} catch {
+			const msg = "Fail to parse version string";
+			this.err("Check update failed", "ERR_VALIDATE", msg);
+			return emitUnavailable(msg, "UNAVAILABLE_ERROR", extraVersionInfo);
+		}
+	}
+	async downloadUpdate(data, info) {
+		const emitError = (code, errorInfo) => {
+			this.err(`Download update failed`, code, errorInfo);
+			this.logger?.debug("Download update end");
+			this.processing = false;
+			return false;
+		};
+		if (this.processing) {
+			this.logger?.info("Updater is already processing, skip download update");
+			return false;
+		}
+		this.processing = true;
+		this.logger?.debug("Download update start");
+		const _sig = info?.signature ?? this.info?.signature;
+		const _version = info?.version ?? this.info?.version;
+		if (!_sig || !_version) return emitError("ERR_PARAM", "No update signature, please call `checkUpdate` first or manually setup params");
+		if (!data && !this.provider) return emitError("ERR_PARAM", "No update asar buffer and provider");
+		const buffer = await this.fetch("buffer", data ? Buffer.from(data) : void 0);
+		if (!buffer) return emitError("ERR_PARAM", "No update asar file buffer");
+		this.logger?.debug("Validation start");
+		if (!await this.provider.verifySignaure(buffer, _version, _sig, this.CERT)) return emitError("ERR_VALIDATE", "Invalid update asar file");
+		this.logger?.debug("Validation end");
+		try {
+			this.tmpFilePath = `${getPathFromAppNameAsar()}.tmp`;
+			this.logger?.debug(`Install to ${this.tmpFilePath}`);
+			fs.writeFileSync(this.tmpFilePath, await this.provider.unzipFile(buffer));
+			this.logger?.info(`Download success, version: ${_version}`);
+			this.info = void 0;
+			this.emit("update-downloaded");
+			this.processing = false;
+			this.logger?.debug("Download update end");
+			return true;
+		} catch (error) {
+			this.cleanup();
+			return emitError("ERR_DOWNLOAD", `Failed to write update file: ${error instanceof Error ? error.message : error}`);
+		}
+	}
+	/**
+	* quit App and install
+	*/
+	quitAndInstall() {
+		this.logger?.info("Quit and install");
+		restartApp();
+	}
+	cancel() {
+		if (this.controller.signal.aborted) return;
+		this.controller.abort();
+		this.cleanup();
+		this.logger?.info("Cancel update");
+		this.emit("update-cancelled");
+		this.controller = new AbortController();
+	}
+};
+/**
+* Auto check update, download and install
+*/
+async function autoUpdate(updater) {
+	if (await updater.checkForUpdates() && await updater.downloadUpdate()) updater.quitAndInstall();
+}
+
+//#endregion
+//#region src/entry/core.ts
+/**
+* Utils to startup with updater
+* @param fn startup function
+* @example
+* // in electron/main/index.ts
+* export default startupWithUpdater((updater) => {
+*   updater.checkUpdate()
+* })
+*/
+function startupWithUpdater(fn) {
+	if (isDev) process.on("message", (msg) => {
+		if (msg === "electron-vite&type=hot-reload") for (const window of BrowserWindow.getAllWindows()) window.reload();
+	});
+	return fn;
+}
+function runWithDefaultExport(mod, args) {
+	return (mod.default || mod)(args);
+}
+const defaultOnInstall = (install, _, __, logger) => {
+	install();
+	logger?.info(`update success!`);
+};
+/**
+* Initialize Electron with updater
+* @example
+* createElectronApp({
+*   updater: {
+*     provider: new GitHubProvider({
+*       username: 'yourname',
+*       repo: 'electron',
+*     }),
+*   },
+*   beforeStart(mainFilePath, logger) {
+*     logger?.debug(mainFilePath)
+*   },
+* })
+*/
+async function createElectronApp(appOptions = {}) {
+	const appNameAsarPath = getPathFromAppNameAsar();
+	const { mainPath = isDev ? path.join(app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "main", __EIU_MAIN_FILE__) : path.join(path.dirname(app.getAppPath()), __EIU_ASAR_BASE_NAME__, "main", __EIU_MAIN_FILE__), updater, onInstall = defaultOnInstall, beforeStart, onStartError } = appOptions;
+	const updaterInstance = typeof updater === "object" || !updater ? new Updater(updater) : await updater();
+	const logger = updaterInstance.logger;
+	try {
+		const tempAsarPath = `${appNameAsarPath}.tmp`;
+		if (fs.existsSync(tempAsarPath)) {
+			logger?.info(`Installing new asar from ${tempAsarPath}`);
+			await onInstall(() => fs.renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
+		}
+		await beforeStart?.(mainPath, logger);
+		if (__EIU_IS_ESM__) runWithDefaultExport(await import(`file://${mainPath}`), updaterInstance);
+		else runWithDefaultExport(require(mainPath), updaterInstance);
+	} catch (error) {
+		logger?.error("Fail to startup", error);
+		onStartError?.(error, logger);
+		app.quit();
+	}
+}
+/**
+* @deprecated Use {@link createElectronApp} instead
+*/
+const initApp = createElectronApp;
+
+//#endregion
+export { Updater, UpdaterError, autoUpdate, createElectronApp, initApp, startupWithUpdater };