electron-incremental-update 2.0.0-beta.8 → 2.0.0

package/dist/chunk-IABBXJFB.js

@@ -0,0 +1,87 @@
+import { __require } from './chunk-RCRKUKFX.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import electron from 'electron';
+
+var isDev = __EIU_IS_DEV__;
+var isWin = process.platform === "win32";
+var isMac = process.platform === "darwin";
+var isLinux = process.platform === "linux";
+function getPathFromAppNameAsar(...paths) {
+  return isDev ? "DEV.asar" : path.join(path.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...paths);
+}
+function getAppVersion() {
+  return isDev ? getEntryVersion() : fs.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+}
+function getEntryVersion() {
+  return electron.app.getVersion();
+}
+function requireNative(moduleName) {
+  if (__EIU_IS_ESM__) {
+    throw new Error(`Cannot require "${path.join(__EIU_ENTRY_DIST_PATH__, moduleName)}", \`requireNative\` only support CommonJS`);
+  }
+  return __require(path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
+}
+function restartApp() {
+  electron.app.relaunch();
+  electron.app.quit();
+}
+function setAppUserModelId(id) {
+  if (isWin) {
+    electron.app.setAppUserModelId(id ?? `org.${electron.app.name}`);
+  }
+}
+function disableHWAccForWin7() {
+  if (!__EIU_IS_ESM__ && __require("node:os").release().startsWith("6.1")) {
+    electron.app.disableHardwareAcceleration();
+  }
+}
+function singleInstance(window) {
+  const result = electron.app.requestSingleInstanceLock();
+  if (result) {
+    electron.app.on("second-instance", () => {
+      if (window) {
+        window.show();
+        if (window.isMinimized()) {
+          window.restore();
+        }
+        window.focus();
+      }
+    });
+  } else {
+    electron.app.quit();
+  }
+  return result;
+}
+function setPortableAppDataPath(dirName = "data") {
+  const portablePath = path.join(path.dirname(electron.app.getPath("exe")), dirName);
+  if (!fs.existsSync(portablePath)) {
+    fs.mkdirSync(portablePath);
+  }
+  electron.app.setPath("appData", portablePath);
+}
+function loadPage(win, htmlFilePath = "index.html") {
+  if (isDev) {
+    win.loadURL(process.env.VITE_DEV_SERVER_URL + htmlFilePath);
+  } else {
+    win.loadFile(getPathFromAppNameAsar("renderer", htmlFilePath));
+  }
+}
+function getPathFromMain(...paths) {
+  return isDev ? path.join(electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "main", ...paths) : getPathFromAppNameAsar("main", ...paths);
+}
+function getPathFromPreload(...paths) {
+  return isDev ? path.join(electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+}
+function getPathFromPublic(...paths) {
+  return isDev ? path.join(electron.app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+}
+function getPathFromEntryAsar(...paths) {
+  return path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
+}
+function handleUnexpectedErrors(callback) {
+  process.on("uncaughtException", callback);
+  process.on("unhandledRejection", callback);
+}
+
+export { disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromMain, getPathFromPreload, getPathFromPublic, handleUnexpectedErrors, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };

package/dist/{chunk-72ZAJ7AF.js → chunk-RCRKUKFX.js}

@@ -25,7 +25,7 @@ function parseVersion(version) {
     ret.stageVersion = Number(_v) || -1;
   }
   if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
-    throw new TypeError(`invalid version: ${version}`);
+    throw new TypeError(`Invalid version: ${version}`);
   }
   return ret;
 }

package/dist/index.cjs

@@ -1,14 +1,15 @@
 'use strict';
 
-var path = require('path');
 var fs3 = require('fs');
-var electron = require('electron');
 var events = require('events');
+var electron = require('electron');
+var path = require('path');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var path__default = /*#__PURE__*/_interopDefault(path);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var electron__default = /*#__PURE__*/_interopDefault(electron);
+var path__default = /*#__PURE__*/_interopDefault(path);
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -27,66 +28,63 @@ process.platform === "win32";
 process.platform === "darwin";
 process.platform === "linux";
 function getPathFromAppNameAsar(...paths) {
-  return isDev ? "DEV.asar" : path__default.default.join(path__default.default.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...paths);
+  return isDev ? "DEV.asar" : path__default.default.join(path__default.default.dirname(electron__default.default.app.getAppPath()), `${electron__default.default.app.name}.asar`, ...paths);
 }
 function getAppVersion() {
   return isDev ? getEntryVersion() : fs3__default.default.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
 }
 function getEntryVersion() {
-  return electron.app.getVersion();
+  return electron__default.default.app.getVersion();
 }
 function restartApp() {
-  electron.app.relaunch();
-  electron.app.quit();
+  electron__default.default.app.relaunch();
+  electron__default.default.app.quit();
 }
 
-// src/updater/types.ts
+// src/entry/types.ts
 var ErrorInfo = {
-  download: "Download failed",
-  validate: "Validate failed",
-  param: "Missing params",
-  network: "Network error"
+  download: "Download Failed",
+  validate: "Validate Failed",
+  param: "Missing Params",
+  network: "Network Error"
 };
 var UpdaterError = class extends Error {
   code;
   constructor(msg, info) {
-    super(ErrorInfo[msg] + ": " + info);
+    super(`[${ErrorInfo[msg]}] ${info}`);
     this.code = msg;
   }
 };
 
-// src/updater/core.ts
+// src/entry/updater.ts
 var Updater = class extends events.EventEmitter {
-  CERT = __EIU_SIGNATURE_CERT__;
+  CERT;
+  controller;
   info;
   provider;
   /**
-   * updater logger
+   * Updater logger
    */
   logger;
   /**
-   * whether to receive beta update
+   * Whether to receive beta update
    */
   receiveBeta;
   /**
-   * whether force update in DEV
+   * Whether force update in DEV
    */
   forceUpdate;
   /**
-   * initialize incremental updater
-   * @param provider update provider
-   * @param option UpdaterOption
+   * Initialize incremental updater
+   * @param options UpdaterOption
    */
-  constructor(provider, option = {}) {
+  constructor(options = {}) {
     super();
-    this.provider = provider;
-    this.receiveBeta = option.receiveBeta;
-    if (option.SIGNATURE_CERT) {
-      this.CERT = option.SIGNATURE_CERT;
-    }
-    if (option.logger) {
-      this.logger = option.logger;
-    }
+    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),
@@ -94,7 +92,10 @@ var Updater = class extends events.EventEmitter {
         warn: (...args) => console.log("[EIU-WARN ]", ...args),
         error: (...args) => console.error("[EIU-ERROR]", ...args)
       };
-      this.logger.info("no logger set, enable dev-only logger");
+      this.logger.info("No logger set, enable dev-only logger");
+    }
+    if (!this.provider) {
+      this.logger?.debug("WARN: No update provider");
     }
   }
   async fetch(format, data) {
@@ -102,90 +103,99 @@ var Updater = class extends events.EventEmitter {
       if (format === "json" && isUpdateJSON(data) || format === "buffer" && Buffer.isBuffer(data)) {
         return data;
       } else {
-        this.err("invalid type", "param", `invalid type at format '${format}': ${JSON.stringify(data)}`);
+        this.err("Invalid type", "param", `Invalid type at format '${format}': ${JSON.stringify(data)}`);
         return;
       }
     }
-    this.logger?.debug(`download from ${this.provider.name}`);
+    this.logger?.debug(`Download from \`${this.provider.name}\``);
     try {
-      const result = format === "json" ? await this.provider.downloadJSON(data ?? __EIU_VERSION_PATH__) : await this.provider.downloadAsar(electron.app.name, this.info, (data2) => this.emit("download-progress", data2));
-      this.logger?.debug(`download ${format} success${format === "buffer" ? `, file size: ${result.length}` : ""}`);
+      const result = format === "json" ? await this.provider.downloadJSON(__EIU_VERSION_PATH__, this.controller.signal) : await this.provider.downloadAsar(electron.app.name, 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`, "network", `download ${format} failed: ${e}`);
+      this.err(`Fetch ${format} failed`, "network", e instanceof Error ? e.message : e.toString());
     }
   }
   /**
-   * handle error message and emit error event
+   * Handle error message and emit error event
    */
   err(msg, code, errorInfo) {
     const err = new UpdaterError(code, errorInfo);
     this.logger?.error(msg, err);
     this.emit("error", err);
   }
-  async checkUpdate(data) {
-    const emitUnavailable = (msg) => {
+  async checkForUpdates(data) {
+    const emitUnavailable = (msg, info2) => {
       this.logger?.info(msg);
-      this.emit("update-unavailable", msg);
+      this.emit("update-not-available", msg, info2);
       return false;
     };
+    if (!data && !this.provider) {
+      this.err("Check update failed", "param", "No update json or provider");
+      return false;
+    }
     const _data = await this.fetch("json", data);
     if (!_data) {
-      return emitUnavailable("failed to get update info");
-    }
-    let { signature, version, minimumVersion, beta } = _data;
-    if (this.receiveBeta) {
-      version = beta.version;
-      signature = beta.signature;
-      minimumVersion = beta.minimumVersion;
+      return emitUnavailable("Failed to get update info");
     }
-    this.logger?.debug(`checked update, version: ${version}, signature: ${signature}`);
+    const { signature, version, minimumVersion } = this.receiveBeta ? _data.beta : _data;
+    const info = { signature, minimumVersion, version };
+    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");
+      return emitUnavailable("Skip check update in dev mode. To force update, set `updater.forceUpdate` to true or call checkUpdate with UpdateJSON", info);
     }
     const isLowerVersion = this.provider.isLowerVersion;
     const entryVersion = getEntryVersion();
     const appVersion = getAppVersion();
-    if (isLowerVersion(entryVersion, minimumVersion)) {
-      return emitUnavailable(`entry version (${entryVersion}) < minimumVersion (${minimumVersion})`);
-    }
-    this.logger?.info(`check update: current version is ${appVersion}, new version is ${version}`);
-    if (!isLowerVersion(appVersion, version)) {
-      return emitUnavailable(`current version (${appVersion}) < new version (${version})`);
+    try {
+      if (isLowerVersion(entryVersion, minimumVersion)) {
+        return emitUnavailable(`Entry Version (${entryVersion}) < MinimumVersion (${minimumVersion})`, info);
+      }
+      this.logger?.info(`Check update: current version is ${appVersion}, new version is ${version}`);
+      if (!isLowerVersion(appVersion, version)) {
+        return emitUnavailable(`Current version (${appVersion}) < New version (${version})`, info);
+      }
+      this.logger?.info(`Update available: ${version}`);
+      this.emit("update-available", info);
+      this.info = info;
+      return true;
+    } catch {
+      this.err("Fail to parse version", "validate", "Fail to parse version string");
+      return false;
     }
-    this.logger?.info(`update available: ${version}`);
-    this.info = { signature, minimumVersion, version };
-    this.emit("update-available", this.info);
-    return true;
   }
   async downloadUpdate(data, info) {
     const _sig = info?.signature ?? this.info?.signature;
     const _version = info?.version ?? this.info?.version;
     if (!_sig || !_version) {
-      this.err("download failed", "param", "no update signature, please call `checkUpdate` first or manually setup params");
+      this.err("Download failed", "param", "No update signature, please call `checkUpdate` first or manually setup params");
+      return false;
+    }
+    if (!data && !this.provider) {
+      this.err("Download failed", "param", "No update asar buffer and provider");
       return false;
     }
     const buffer = await this.fetch("buffer", data ? Buffer.from(data) : void 0);
     if (!buffer) {
-      this.err("download failed", "param", "no update asar file buffer");
+      this.err("Download failed", "param", "No update asar file buffer");
       return false;
     }
     this.logger?.debug("verify start");
     if (!await this.provider.verifySignaure(buffer, _version, _sig, this.CERT)) {
-      this.err("download failed", "validate", "invalid update asar file");
+      this.err("Download failed", "validate", "Invalid update asar file");
       return false;
     }
-    this.logger?.debug("verify success");
+    this.logger?.debug("Verify success");
     try {
-      const tmpFilePath = getPathFromAppNameAsar() + ".tmp";
-      this.logger?.debug(`install to ${tmpFilePath}`);
+      const tmpFilePath = `${getPathFromAppNameAsar()}.tmp`;
+      this.logger?.debug(`Install to ${tmpFilePath}`);
       fs3__default.default.writeFileSync(tmpFilePath, await this.provider.unzipFile(buffer));
-      this.logger?.info(`download success, version: ${_version}`);
+      this.logger?.info(`Download success, version: ${_version}`);
       this.info = void 0;
       this.emit("update-downloaded");
       return true;
     } catch (error) {
-      this.err("download failed", "download", `fail to unwrap asar file, ${error}`);
+      this.err("Download failed", "download", `Fail to unwrap asar file, ${error}`);
       return false;
     }
   }
@@ -193,26 +203,24 @@ var Updater = class extends events.EventEmitter {
    * quit App and install
    */
   quitAndInstall() {
-    this.logger?.info("quit and install");
+    this.logger?.info("Quit and install");
     restartApp();
   }
-  /**
-   * setup provider URL handler
-   *
-   * @example
-   * updater.setURLHandler((url, isDownloadingAsar) => {
-   *   if (isDownloadingAsar) {
-   *     url.hostname = 'https://cdn.jsdelivr.net/gh'
-   *     return url
-   *   }
-   * })
-   */
-  setURLHandler(handler) {
-    this.provider.urlHandler = handler;
+  cancel() {
+    if (this.controller.signal.aborted) {
+      return;
+    }
+    this.controller.abort();
+    this.logger?.info("Cancel update");
+    this.emit("update-cancelled");
+    this.controller = new AbortController();
   }
 };
-
-// src/entry.ts
+async function autoUpdate(updater) {
+  if (await updater.checkForUpdates() && await updater.downloadUpdate()) {
+    updater.quitAndInstall();
+  }
+}
 function startupWithUpdater(fn) {
   return fn;
 }
@@ -220,9 +228,14 @@ var defaultOnInstall = (install, _, __, logger) => {
   install();
   logger?.info(`update success!`);
 };
-async function initApp(appOptions) {
+async function createElectronApp(appOptions = {}) {
+  const appNameAsarPath = getPathFromAppNameAsar();
   const {
-    provider,
+    mainPath = path__default.default.join(
+      isDev ? path__default.default.join(electron.app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
+      "main",
+      __EIU_MAIN_FILE__
+    ),
     updater,
     onInstall = defaultOnInstall,
     beforeStart,
@@ -230,42 +243,35 @@ async function initApp(appOptions) {
   } = appOptions;
   let updaterInstance;
   if (typeof updater === "object" || !updater) {
-    updaterInstance = new Updater(provider, updater);
+    updaterInstance = new Updater(updater);
   } else {
     updaterInstance = await updater();
   }
-  let logger = updaterInstance.logger;
-  if (isDev && !logger) {
-    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)
-    };
-  }
+  const logger = updaterInstance.logger;
   try {
-    const appNameAsarPath = getPathFromAppNameAsar();
     const tempAsarPath = `${appNameAsarPath}.tmp`;
     if (fs3__default.default.existsSync(tempAsarPath)) {
-      logger?.info(`installing new asar: ${tempAsarPath}`);
+      logger?.info(`Installing new asar from ${tempAsarPath}`);
       await onInstall(() => fs3__default.default.renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
     }
-    const mainFilePath = path__default.default.join(
-      isDev ? path__default.default.join(electron.app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
-      "main",
-      __EIU_MAIN_FILE__
-    );
-    await beforeStart?.(mainFilePath, logger);
-    __require(mainFilePath)(updaterInstance);
+    await beforeStart?.(mainPath, logger);
+    if (__EIU_IS_ESM__) {
+      (await import(`file://${mainPath}`)).default(updaterInstance);
+    } else {
+      __require(mainPath)(updaterInstance);
+    }
   } catch (error) {
     logger?.error("startup error", error);
     onStartError?.(error, logger);
     electron.app.quit();
   }
 }
+var initApp = createElectronApp;
 
 exports.ErrorInfo = ErrorInfo;
 exports.Updater = Updater;
 exports.UpdaterError = UpdaterError;
+exports.autoUpdate = autoUpdate;
+exports.createElectronApp = createElectronApp;
 exports.initApp = initApp;
 exports.startupWithUpdater = startupWithUpdater;