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

package/dist/index.js

@@ -1,57 +1,54 @@
-import { isDev, getEntryVersion, getAppVersion, getPathFromAppNameAsar, restartApp } from './chunk-4MH6ZXCY.js';
-import { isUpdateJSON, __require } from './chunk-72ZAJ7AF.js';
-import path from 'node:path';
+import { isDev, getEntryVersion, getAppVersion, getPathFromAppNameAsar, restartApp } from './chunk-IABBXJFB.js';
+import { isUpdateJSON, __require } from './chunk-RCRKUKFX.js';
 import fs2 from 'node:fs';
-import { app } from 'electron';
 import { EventEmitter } from 'node:events';
+import { app } from 'electron';
+import path from 'node:path';
 
-// 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 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),
@@ -59,7 +56,10 @@ var Updater = class extends 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) {
@@ -67,90 +67,99 @@ var Updater = class extends 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(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(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");
+      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;
-    }
-    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}`);
       fs2.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;
     }
   }
@@ -158,26 +167,24 @@ var Updater = class extends 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;
 }
@@ -185,9 +192,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.join(
+      isDev ? path.join(app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
+      "main",
+      __EIU_MAIN_FILE__
+    ),
     updater,
     onInstall = defaultOnInstall,
     beforeStart,
@@ -195,38 +207,29 @@ 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 (fs2.existsSync(tempAsarPath)) {
-      logger?.info(`installing new asar: ${tempAsarPath}`);
+      logger?.info(`Installing new asar from ${tempAsarPath}`);
       await onInstall(() => fs2.renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
     }
-    const mainFilePath = path.join(
-      isDev ? path.join(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);
     app.quit();
   }
 }
+var initApp = createElectronApp;
 
-export { ErrorInfo, Updater, UpdaterError, initApp, startupWithUpdater };
+export { ErrorInfo, Updater, UpdaterError, autoUpdate, createElectronApp, initApp, startupWithUpdater };

package/dist/provider.cjs

@@ -7,6 +7,7 @@ var zlib = require('zlib');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var electron__default = /*#__PURE__*/_interopDefault(electron);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var zlib__default = /*#__PURE__*/_interopDefault(zlib);
 
@@ -32,7 +33,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;
 }
@@ -62,19 +63,19 @@ function isUpdateJSON(json) {
 }
 
 // src/provider/download.ts
-function getHeader(response, headerKey) {
-  const value = response.headers[headerKey];
+function getHeader(headers, key) {
+  const value = headers[key];
   if (Array.isArray(value)) {
     return value.length === 0 ? null : value[value.length - 1];
   } else {
     return value;
   }
 }
-async function downloadFn(url, headers, onResponse) {
-  await electron.app.whenReady();
+async function downloadFn(url, headers, signal, onResponse) {
+  await electron__default.default.app.whenReady();
   return new Promise((resolve, reject) => {
-    const request = electron.net.request({ url, method: "GET", redirect: "follow" });
-    Object.keys(headers).forEach((key) => request.setHeader(key, headers[key]));
+    const request = electron__default.default.net.request({ url, method: "GET", redirect: "follow", headers, cache: "no-cache" });
+    signal.addEventListener("abort", () => request.abort(), { once: true });
     request.on("response", (resp) => {
       resp.on("aborted", () => reject(new Error("aborted")));
       resp.on("error", () => reject(new Error("download error")));
@@ -84,46 +85,56 @@ async function downloadFn(url, headers, onResponse) {
     request.end();
   });
 }
-async function defaultDownloadUpdateJSON(url, headers) {
-  return await downloadFn(url, headers, (resp, resolve, reject) => {
-    let data = "";
-    resp.on("data", (chunk) => data += chunk);
-    resp.on("end", () => {
-      try {
-        const json = JSON.parse(data);
-        if (isUpdateJSON(json)) {
-          resolve(json);
-        } else {
-          throw Error;
+async function defaultDownloadUpdateJSON(url, headers, signal) {
+  return await downloadFn(
+    url,
+    headers,
+    signal,
+    (resp, resolve, reject) => {
+      let data = "";
+      resp.on("data", (chunk) => data += chunk);
+      resp.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (isUpdateJSON(json)) {
+            resolve(json);
+          } else {
+            throw Error;
+          }
+        } catch {
+          reject(new Error(`Invalid update json, "${data}"`));
         }
-      } catch {
-        reject(new Error("invalid update json"));
-      }
-    });
-  });
+      });
+    }
+  );
 }
-async function defaultDownloadAsar(url, headers, onDownloading) {
+async function defaultDownloadAsar(url, headers, signal, onDownloading) {
   let transferred = 0;
   let time = Date.now();
-  return await downloadFn(url, headers, (resp, resolve) => {
-    const total = getHeader(resp.headers, "content-length") || -1;
-    let data = [];
-    resp.on("data", (chunk) => {
-      const delta = chunk.length;
-      transferred += delta;
-      const current = Date.now();
-      onDownloading?.({
-        percent: +(transferred / total).toFixed(2) * 100,
-        total,
-        transferred,
-        delta,
-        bps: delta / ((current - time) * 1e3)
+  return await downloadFn(
+    url,
+    headers,
+    signal,
+    (resp, resolve) => {
+      const total = +getHeader(resp.headers, "content-length") || -1;
+      const data = [];
+      resp.on("data", (chunk) => {
+        const delta = chunk.length;
+        transferred += delta;
+        const current = Date.now();
+        onDownloading?.({
+          percent: total ? +(transferred / total).toFixed(2) * 100 : -1,
+          total,
+          transferred,
+          delta,
+          bps: delta / (current - time)
+        });
+        time = current;
+        data.push(chunk);
       });
-      time = current;
-      data.push(chunk);
-    });
-    resp.on("end", () => resolve(Buffer.concat(data)));
-  });
+      resp.on("end", () => resolve(Buffer.concat(data)));
+    }
+  );
 }
 function hashBuffer(data, length) {
   const hash = crypto__default.default.createHash("SHA256").update(data).digest("binary");
@@ -159,8 +170,17 @@ async function defaultUnzipFile(buffer) {
 // src/provider/base.ts
 var BaseProvider = class {
   name = "BaseProvider";
+  /**
+   * @inheritdoc
+   */
   isLowerVersion = defaultIsLowerVersion;
+  /**
+   * @inheritdoc
+   */
   verifySignaure = defaultVerifySignature;
+  /**
+   * @inheritdoc
+   */
   unzipFile = defaultUnzipFile;
 };
 
@@ -170,15 +190,18 @@ var GitHubProvider = class extends BaseProvider {
   options;
   /**
    * Update Provider for Github repo
-   * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+   * - download update json from `https://github.com/{user}/{repo}/raw/HEAD/{versionPath}`
    * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
    *
-   * you can setup `urlHandler` in {@link GitHubProviderOptions} or `Updater` to modify url before request
+   * you can setup `urlHandler` in {@link GitHubProviderOptions} to modify url before request
    * @param options provider options
    */
   constructor(options) {
     super();
     this.options = options;
+    if (!options.branch) {
+      this.options.branch = "HEAD";
+    }
   }
   get urlHandler() {
     return this.options.urlHandler;
@@ -186,23 +209,31 @@ var GitHubProvider = class extends BaseProvider {
   set urlHandler(handler) {
     this.options.urlHandler = handler;
   }
-  async parseURL(isDownloadAsar, extraPath) {
+  async parseURL(extraPath) {
     const url$1 = new url.URL(
-      `/${this.options.username}/${this.options.repo}/${extraPath}`,
-      "https://" + (isDownloadAsar ? "github.com" : "raw.githubusercontent.com")
+      `/${this.options.user}/${this.options.repo}/${extraPath}`,
+      "https://github.com"
     );
-    return (await this.urlHandler?.(url$1, isDownloadAsar) || url$1).toString();
+    return (await this.urlHandler?.(url$1) || url$1).toString();
   }
-  async downloadJSON(versionPath) {
+  /**
+   * @inheritdoc
+   */
+  async downloadJSON(versionPath, signal) {
     return await defaultDownloadUpdateJSON(
-      await this.parseURL(false, `${this.options.branch ?? "HEAD"}/${versionPath}`),
-      { accept: "application/json", ...this.options.extraHeaders }
+      await this.parseURL(`raw/${this.options.branch}/${versionPath}`),
+      { Accept: "application/json", ...this.options.extraHeaders },
+      signal
     );
   }
-  async downloadAsar(name, info, onDownloading) {
+  /**
+   * @inheritdoc
+   */
+  async downloadAsar(name, info, signal, onDownloading) {
     return await defaultDownloadAsar(
-      await this.parseURL(true, `releases/download/v${info.version}/${name}-${info.version}.asar.gz`),
-      { accept: "application/octet-stream", ...this.options.extraHeaders },
+      await this.parseURL(`releases/download/v${info.version}/${name}-${info.version}.asar.gz`),
+      { Accept: "application/octet-stream", ...this.options.extraHeaders },
+      signal,
       onDownloading
     );
   }