electron-incremental-update 0.9.0 → 1.0.0

package/dist/index.js

@@ -20,41 +20,85 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  IncrementalUpdater: () => IncrementalUpdater,
+  DownloadError: () => DownloadError,
+  MinimumVersionError: () => MinimumVersionError,
+  Updater: () => Updater,
+  VerifyFailedError: () => VerifyFailedError,
   createUpdater: () => createUpdater,
-  initApp: () => initApp
+  initApp: () => initApp,
+  startupWithUpdater: () => startupWithUpdater
 });
 module.exports = __toCommonJS(src_exports);
-var import_node_path3 = require("path");
-var import_node_fs5 = require("fs");
+var import_node_path2 = require("path");
+var import_node_fs4 = require("fs");
 var import_electron4 = require("electron");
 
-// src/updater/index.ts
-var import_node_fs4 = require("fs");
+// src/updater/core.ts
+var import_node_fs3 = require("fs");
 var import_promises = require("fs/promises");
+var import_electron3 = require("electron");
 
-// src/utils/core.ts
+// src/utils/electron.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
+var import_node_os = require("os");
 var import_electron = require("electron");
-var DEFAULT_APP_NAME = "product";
 var is = {
   dev: !import_electron.app.isPackaged,
   win: process.platform === "win32",
   mac: process.platform === "darwin",
   linux: process.platform === "linux"
 };
-function getProductAsarPath(name = DEFAULT_APP_NAME) {
-  return !import_electron.app.isPackaged ? (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${name}.asar`) : "DEV.asar";
+function getPathFromAppNameAsar(...path) {
+  return is.dev ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${import_electron.app.name}.asar`, ...path);
 }
-function getElectronVersion() {
-  return import_electron.app.getVersion();
+function getVersions() {
+  const platform = is.win ? "Windows" : is.mac ? "MacOS" : process.platform.toUpperCase();
+  return {
+    appVersion: is.dev ? import_electron.app.getVersion() : (0, import_node_fs.readFileSync)(getPathFromAppNameAsar("version"), "utf-8"),
+    entryVersion: import_electron.app.getVersion(),
+    electronVersion: process.versions.electron,
+    nodeVersion: process.versions.node,
+    systemVersion: `${platform} ${(0, import_node_os.release)()}`
+  };
+}
+function restartApp() {
+  import_electron.app.relaunch();
+  import_electron.app.quit();
 }
-function getAppVersion(name = DEFAULT_APP_NAME) {
-  return import_electron.app.isPackaged ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(getProductAsarPath(name), "version"), "utf-8") : getElectronVersion();
+function waitAppReady(timeout = 1e3) {
+  return import_electron.app.isReady() ? Promise.resolve() : new Promise((resolve2, reject) => {
+    const _ = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, timeout);
+    import_electron.app.whenReady().then(() => {
+      clearTimeout(_);
+      resolve2();
+    });
+  });
+}
+
+// src/utils/zip.ts
+var import_node_fs2 = require("fs");
+var import_node_zlib = require("zlib");
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
+  if (!(0, import_node_fs2.existsSync)(gzipPath)) {
+    throw new Error(`path to zipped file not exist: ${gzipPath}`);
+  }
+  const compressedBuffer = (0, import_node_fs2.readFileSync)(gzipPath);
+  return new Promise((resolve2, reject) => {
+    (0, import_node_zlib.gunzip)(compressedBuffer, (err, buffer) => {
+      (0, import_node_fs2.rmSync)(gzipPath);
+      if (err) {
+        reject(err);
+      }
+      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer);
+      resolve2(null);
+    });
+  });
 }
 
-// src/utils/version.ts
+// src/utils/noDep.ts
 function parseVersion(version) {
   const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
   const match = semver.exec(version);
@@ -79,41 +123,9 @@ function parseVersion(version) {
   }
   return ret;
 }
-
-// src/utils/zip.ts
-var import_node_fs2 = require("fs");
-var import_node_zlib = require("zlib");
-async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
-  if (!(0, import_node_fs2.existsSync)(gzipPath)) {
-    throw new Error(`path to zipped file not exist: ${gzipPath}`);
-  }
-  const compressedBuffer = (0, import_node_fs2.readFileSync)(gzipPath);
-  return new Promise((resolve2, reject) => {
-    (0, import_node_zlib.gunzip)(compressedBuffer, (err, buffer) => {
-      (0, import_node_fs2.rmSync)(gzipPath);
-      if (err) {
-        reject(err);
-      }
-      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer);
-      resolve2(null);
-    });
-  });
-}
-
-// src/utils/utils.ts
-var import_node_path2 = require("path");
-var import_node_fs3 = require("fs");
-var import_electron2 = require("electron");
-function waitAppReady(timeout = 1e3) {
-  return import_electron2.app.isReady() ? Promise.resolve() : new Promise((resolve2, reject) => {
-    const _ = setTimeout(() => {
-      reject(new Error("app is not ready"));
-    }, timeout);
-    import_electron2.app.whenReady().then(() => {
-      clearTimeout(_);
-      resolve2();
-    });
-  });
+function isUpdateJSON(json) {
+  const is2 = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  return is2(json) && is2(json?.beta);
 }
 
 // src/crypto.ts
@@ -138,12 +150,6 @@ var verify = (buffer, signature, cert) => {
   }
 };
 
-// src/updateJson.ts
-function isUpdateJSON(json) {
-  const is2 = (j) => "signature" in j && "version" in j && "size" in j && "minimumVersion" in j;
-  return is2(json) && "beta" in json && is2(json.beta);
-}
-
 // src/updater/types.ts
 var MinimumVersionError = class extends Error {
   currentVersion;
@@ -169,12 +175,12 @@ var DownloadError = class extends Error {
   }
 };
 
-// src/updater/defaultFunctions.ts
-var import_electron3 = require("electron");
+// src/updater/defaultFunctions/download.ts
+var import_electron2 = require("electron");
 var downloadJSONDefault = async (url, headers) => {
   await waitAppReady();
   return new Promise((resolve2, reject) => {
-    const request = import_electron3.net.request({
+    const request = import_electron2.net.request({
       url,
       method: "GET",
       redirect: "follow"
@@ -208,7 +214,7 @@ var downloadBufferDefault = async (url, headers, total, onDownloading) => {
   await waitAppReady();
   let current = 0;
   return new Promise((resolve2, reject) => {
-    const request = import_electron3.net.request({
+    const request = import_electron2.net.request({
       url,
       method: "GET",
       redirect: "follow"
@@ -236,6 +242,8 @@ var downloadBufferDefault = async (url, headers, total, onDownloading) => {
     request.end();
   });
 };
+
+// src/updater/defaultFunctions/compareVersion.ts
 var compareVersionDefault = (version1, version2) => {
   const oldV = parseVersion(version1);
   const newV = parseVersion(version2);
@@ -257,49 +265,60 @@ var compareVersionDefault = (version1, version2) => {
   return false;
 };
 
-// src/updater/index.ts
-var IncrementalUpdater = class {
+// src/updater/core.ts
+var Updater = class {
   info;
   option;
   asarPath;
   gzipPath;
   tmpFilePath;
+  /**
+   * updater logger
+   */
   logger;
+  /**
+   * downloading progress hook
+   * @param progress download progress
+   * @example
+   * updater.onDownloading = ({ percent, total, current }) => {
+   *   console.log(`download progress: ${percent}, total: ${total}, current: ${current}`)
+   * }
+   */
   onDownloading;
-  get productName() {
-    return this.option.productName;
-  }
+  /**
+   * whether receive beta version
+   */
   get receiveBeta() {
     return !!this.option.receiveBeta;
   }
   set receiveBeta(receiveBeta) {
     this.option.receiveBeta = receiveBeta;
   }
+  /**
+   * initialize incremental updater
+   * @param option UpdaterOption
+   */
   constructor(option) {
     this.option = option;
-    if (!option.productName) {
-      this.option.productName = DEFAULT_APP_NAME;
-    }
-    this.asarPath = getProductAsarPath(this.productName);
+    this.asarPath = getPathFromAppNameAsar();
     this.gzipPath = `${this.asarPath}.gz`;
     this.tmpFilePath = `${this.asarPath}.tmp`;
   }
   async needUpdate(version, minVersion) {
     const compare = this.option.overrideFunctions?.compareVersion ?? compareVersionDefault;
-    const productVersion = getAppVersion(this.option.productName);
-    const entryVersion = getElectronVersion();
+    const { appVersion, entryVersion } = getVersions();
     if (await compare(entryVersion, minVersion)) {
       throw new MinimumVersionError(entryVersion, minVersion);
     }
-    this.logger?.info(`check update: current version is ${productVersion}, new version is ${version}`);
-    return await compare(productVersion, version);
+    this.logger?.info(`check update: current version is ${appVersion}, new version is ${version}`);
+    return await compare(appVersion, version);
   }
   async parseData(format, data) {
-    if ((0, import_node_fs4.existsSync)(this.tmpFilePath)) {
+    if ((0, import_node_fs3.existsSync)(this.tmpFilePath)) {
       this.logger?.warn(`remove tmp file: ${this.tmpFilePath}`);
       await (0, import_promises.rm)(this.tmpFilePath);
     }
-    if ((0, import_node_fs4.existsSync)(this.gzipPath)) {
+    if ((0, import_node_fs3.existsSync)(this.gzipPath)) {
       this.logger?.warn(`remove .gz file: ${this.gzipPath}`);
       await (0, import_promises.rm)(this.gzipPath);
     }
@@ -327,7 +346,7 @@ var IncrementalUpdater = class {
     } : {
       name: "releaseAsarURL",
       url: this.option.releaseAsarURL,
-      repoFallback: `${this.option.repository}/releases/download/v${this.info?.version}/${this.productName}-${this.info?.version}.asar.gz`,
+      repoFallback: `${this.option.repository}/releases/download/v${this.info?.version}/${import_electron3.app.name}-${this.info?.version}.asar.gz`,
       fn: this.option.overrideFunctions?.downloadBuffer ?? downloadBufferDefault
     };
     data ??= config.url;
@@ -350,6 +369,16 @@ var IncrementalUpdater = class {
       throw new DownloadError(e.toString());
     }
   }
+  /**
+   * check update info
+   *
+   * if you want to update **offline**, you can set `data` and `sig` add update info
+   * @param data custom download URL of `updatejson` or existing update json
+   * @returns
+   * - Available:`{size: number, version: string}`
+   * - Unavailable: `undefined`
+   * - Fail: `CheckResultError`
+   */
   async checkUpdate(data) {
     try {
       let { signature, size, version, minimumVersion, beta } = await this.parseData("json", data);
@@ -371,13 +400,23 @@ var IncrementalUpdater = class {
           version,
           size
         };
-        return { size, version };
+        return this.info;
       }
     } catch (error) {
       this.logger?.error("check update failed", error);
       return error;
     }
   }
+  /**
+   * download update
+   *
+   * if you want to update **offline**, you can set both `data` and `sig` to verify and install
+   * @param data custom download URL of `asar.gz` or existing `asar.gz` buffer
+   * @param sig signature
+   * @returns
+   * - `true`: success
+   * - `DownloadResultError`: fail
+   */
   async download(data, sig) {
     try {
       const _sig = sig ?? this.info?.signature;
@@ -404,48 +443,66 @@ var IncrementalUpdater = class {
       return error;
     }
   }
+  /**
+   * quit App and install
+   */
+  quitAndInstall() {
+    this.logger?.info("quit and install");
+    restartApp();
+  }
 };
+
+// src/updater/index.ts
 function createUpdater(option) {
-  return new IncrementalUpdater(option);
+  return new Updater(option);
 }
 
 // src/index.ts
+function startupWithUpdater(fn) {
+  return fn;
+}
+var defaultOnInstall = (install, _, __, logger) => {
+  install();
+  logger?.info(`update success!`);
+};
 function initApp(appOptions) {
   const {
-    electronDevDistPath = "dist-electron",
+    electronDevDistPath = "../dist-electron",
     mainPath = "main/index.js",
     hooks
   } = appOptions || {};
   const {
-    beforeDoUpdate,
+    onInstall = defaultOnInstall,
     beforeStart,
     onStartError
   } = hooks || {};
-  function handleError(msg) {
-    onStartError?.(new Error(msg));
+  function handleError(err, logger) {
+    console.error(err);
+    onStartError?.(err, logger);
     import_electron4.app.quit();
   }
   async function startup(updater) {
+    const logger = updater.logger;
     try {
-      const asarPath = getProductAsarPath(updater.productName);
-      const updateAsarPath = `${asarPath}.tmp`;
-      if ((0, import_node_fs5.existsSync)(updateAsarPath)) {
-        await beforeDoUpdate?.(asarPath, updateAsarPath);
-        (0, import_node_fs5.renameSync)(updateAsarPath, asarPath);
+      const appNameAsarPath = getPathFromAppNameAsar();
+      const tempAsarPath = `${appNameAsarPath}.tmp`;
+      if ((0, import_node_fs4.existsSync)(tempAsarPath)) {
+        logger?.info(`installing new asar: ${tempAsarPath}`);
+        await onInstall(() => (0, import_node_fs4.renameSync)(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
       }
-      const mainDir = import_electron4.app.isPackaged ? asarPath : electronDevDistPath;
-      const entry = (0, import_node_path3.resolve)(__dirname, mainDir, mainPath);
-      await beforeStart?.(entry);
+      const mainDir = is.dev ? electronDevDistPath : appNameAsarPath;
+      const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
+      await beforeStart?.(entry, logger);
       require(entry)(updater);
     } catch (error) {
-      handleError(`failed to start app, ${error}`);
+      handleError(error, logger);
     }
   }
   let timer = setTimeout(() => {
-    handleError("start app timeout, please call .setUpdater() to set updater and start");
+    handleError("start app timeout, please start app with `initApp(options).startupWithUpdater(options)`");
   }, 3e3);
   return {
-    async setUpdater(updater) {
+    async startupWithUpdater(updater) {
       clearTimeout(timer);
       if (typeof updater === "object") {
         await startup(createUpdater(updater));
@@ -459,7 +516,11 @@ function initApp(appOptions) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  IncrementalUpdater,
+  DownloadError,
+  MinimumVersionError,
+  Updater,
+  VerifyFailedError,
   createUpdater,
-  initApp
+  initApp,
+  startupWithUpdater
 });

package/dist/index.mjs

@@ -1,28 +1,29 @@
 import {
-  isUpdateJSON,
   verify
-} from "./chunk-5BZLJPHJ.mjs";
+} from "./chunk-GXZSAUBR.mjs";
 import {
-  DEFAULT_APP_NAME,
-  getAppVersion,
-  getElectronVersion,
-  getProductAsarPath,
+  getPathFromAppNameAsar,
+  getVersions,
+  is,
+  restartApp,
   waitAppReady
-} from "./chunk-6UZHBPFT.mjs";
+} from "./chunk-OUZLSVQC.mjs";
 import {
   __require,
+  isUpdateJSON,
   parseVersion,
   unzipFile
-} from "./chunk-CMBFI77K.mjs";
+} from "./chunk-GB6VLKJZ.mjs";
 
 // src/index.ts
 import { resolve } from "node:path";
 import { existsSync as existsSync2, renameSync } from "node:fs";
-import { app } from "electron";
+import { app as app2 } from "electron";
 
-// src/updater/index.ts
+// src/updater/core.ts
 import { existsSync } from "node:fs";
 import { rm, writeFile } from "node:fs/promises";
+import { app } from "electron";
 
 // src/updater/types.ts
 var MinimumVersionError = class extends Error {
@@ -49,7 +50,7 @@ var DownloadError = class extends Error {
   }
 };
 
-// src/updater/defaultFunctions.ts
+// src/updater/defaultFunctions/download.ts
 import { net } from "electron";
 var downloadJSONDefault = async (url, headers) => {
   await waitAppReady();
@@ -116,6 +117,8 @@ var downloadBufferDefault = async (url, headers, total, onDownloading) => {
     request.end();
   });
 };
+
+// src/updater/defaultFunctions/compareVersion.ts
 var compareVersionDefault = (version1, version2) => {
   const oldV = parseVersion(version1);
   const newV = parseVersion(version2);
@@ -137,42 +140,53 @@ var compareVersionDefault = (version1, version2) => {
   return false;
 };
 
-// src/updater/index.ts
-var IncrementalUpdater = class {
+// src/updater/core.ts
+var Updater = class {
   info;
   option;
   asarPath;
   gzipPath;
   tmpFilePath;
+  /**
+   * updater logger
+   */
   logger;
+  /**
+   * downloading progress hook
+   * @param progress download progress
+   * @example
+   * updater.onDownloading = ({ percent, total, current }) => {
+   *   console.log(`download progress: ${percent}, total: ${total}, current: ${current}`)
+   * }
+   */
   onDownloading;
-  get productName() {
-    return this.option.productName;
-  }
+  /**
+   * whether receive beta version
+   */
   get receiveBeta() {
     return !!this.option.receiveBeta;
   }
   set receiveBeta(receiveBeta) {
     this.option.receiveBeta = receiveBeta;
   }
+  /**
+   * initialize incremental updater
+   * @param option UpdaterOption
+   */
   constructor(option) {
     this.option = option;
-    if (!option.productName) {
-      this.option.productName = DEFAULT_APP_NAME;
-    }
-    this.asarPath = getProductAsarPath(this.productName);
+    this.asarPath = getPathFromAppNameAsar();
     this.gzipPath = `${this.asarPath}.gz`;
     this.tmpFilePath = `${this.asarPath}.tmp`;
   }
   async needUpdate(version, minVersion) {
     const compare = this.option.overrideFunctions?.compareVersion ?? compareVersionDefault;
-    const productVersion = getAppVersion(this.option.productName);
-    const entryVersion = getElectronVersion();
+    const { appVersion, entryVersion } = getVersions();
     if (await compare(entryVersion, minVersion)) {
       throw new MinimumVersionError(entryVersion, minVersion);
     }
-    this.logger?.info(`check update: current version is ${productVersion}, new version is ${version}`);
-    return await compare(productVersion, version);
+    this.logger?.info(`check update: current version is ${appVersion}, new version is ${version}`);
+    return await compare(appVersion, version);
   }
   async parseData(format, data) {
     if (existsSync(this.tmpFilePath)) {
@@ -207,7 +221,7 @@ var IncrementalUpdater = class {
     } : {
       name: "releaseAsarURL",
       url: this.option.releaseAsarURL,
-      repoFallback: `${this.option.repository}/releases/download/v${this.info?.version}/${this.productName}-${this.info?.version}.asar.gz`,
+      repoFallback: `${this.option.repository}/releases/download/v${this.info?.version}/${app.name}-${this.info?.version}.asar.gz`,
       fn: this.option.overrideFunctions?.downloadBuffer ?? downloadBufferDefault
     };
     data ??= config.url;
@@ -230,6 +244,16 @@ var IncrementalUpdater = class {
       throw new DownloadError(e.toString());
     }
   }
+  /**
+   * check update info
+   *
+   * if you want to update **offline**, you can set `data` and `sig` add update info
+   * @param data custom download URL of `updatejson` or existing update json
+   * @returns
+   * - Available:`{size: number, version: string}`
+   * - Unavailable: `undefined`
+   * - Fail: `CheckResultError`
+   */
   async checkUpdate(data) {
     try {
       let { signature, size, version, minimumVersion, beta } = await this.parseData("json", data);
@@ -251,13 +275,23 @@ var IncrementalUpdater = class {
           version,
           size
         };
-        return { size, version };
+        return this.info;
       }
     } catch (error) {
       this.logger?.error("check update failed", error);
       return error;
     }
   }
+  /**
+   * download update
+   *
+   * if you want to update **offline**, you can set both `data` and `sig` to verify and install
+   * @param data custom download URL of `asar.gz` or existing `asar.gz` buffer
+   * @param sig signature
+   * @returns
+   * - `true`: success
+   * - `DownloadResultError`: fail
+   */
   async download(data, sig) {
     try {
       const _sig = sig ?? this.info?.signature;
@@ -284,48 +318,66 @@ var IncrementalUpdater = class {
       return error;
     }
   }
+  /**
+   * quit App and install
+   */
+  quitAndInstall() {
+    this.logger?.info("quit and install");
+    restartApp();
+  }
 };
+
+// src/updater/index.ts
 function createUpdater(option) {
-  return new IncrementalUpdater(option);
+  return new Updater(option);
 }
 
 // src/index.ts
+function startupWithUpdater(fn) {
+  return fn;
+}
+var defaultOnInstall = (install, _, __, logger) => {
+  install();
+  logger?.info(`update success!`);
+};
 function initApp(appOptions) {
   const {
-    electronDevDistPath = "dist-electron",
+    electronDevDistPath = "../dist-electron",
     mainPath = "main/index.js",
     hooks
   } = appOptions || {};
   const {
-    beforeDoUpdate,
+    onInstall = defaultOnInstall,
     beforeStart,
     onStartError
   } = hooks || {};
-  function handleError(msg) {
-    onStartError?.(new Error(msg));
-    app.quit();
+  function handleError(err, logger) {
+    console.error(err);
+    onStartError?.(err, logger);
+    app2.quit();
   }
   async function startup(updater) {
+    const logger = updater.logger;
     try {
-      const asarPath = getProductAsarPath(updater.productName);
-      const updateAsarPath = `${asarPath}.tmp`;
-      if (existsSync2(updateAsarPath)) {
-        await beforeDoUpdate?.(asarPath, updateAsarPath);
-        renameSync(updateAsarPath, asarPath);
+      const appNameAsarPath = getPathFromAppNameAsar();
+      const tempAsarPath = `${appNameAsarPath}.tmp`;
+      if (existsSync2(tempAsarPath)) {
+        logger?.info(`installing new asar: ${tempAsarPath}`);
+        await onInstall(() => renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
       }
-      const mainDir = app.isPackaged ? asarPath : electronDevDistPath;
+      const mainDir = is.dev ? electronDevDistPath : appNameAsarPath;
       const entry = resolve(__dirname, mainDir, mainPath);
-      await beforeStart?.(entry);
+      await beforeStart?.(entry, logger);
       __require(entry)(updater);
     } catch (error) {
-      handleError(`failed to start app, ${error}`);
+      handleError(error, logger);
     }
   }
   let timer = setTimeout(() => {
-    handleError("start app timeout, please call .setUpdater() to set updater and start");
+    handleError("start app timeout, please start app with `initApp(options).startupWithUpdater(options)`");
   }, 3e3);
   return {
-    async setUpdater(updater) {
+    async startupWithUpdater(updater) {
       clearTimeout(timer);
       if (typeof updater === "object") {
         await startup(createUpdater(updater));
@@ -338,7 +390,11 @@ function initApp(appOptions) {
   };
 }
 export {
-  IncrementalUpdater,
+  DownloadError,
+  MinimumVersionError,
+  Updater,
+  VerifyFailedError,
   createUpdater,
-  initApp
+  initApp,
+  startupWithUpdater
 };