electron-incremental-update 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,13 +1,9 @@
 import { Buffer } from 'node:buffer';
 
-type CheckResultType = Error | false | Omit<UpdateJSON, 'signature'>;
+type CheckResultType = Omit<UpdateJSON, 'signature'> | undefined | Error;
+type DownloadResult = true | Error;
 type UpdateEvents = {
-    check: null;
-    checkResult: [data: CheckResultType];
-    download: null;
-    downloading: [current: number];
-    downloaded: null;
-    donwnloadError: [error: unknown];
+    downloading: [progress: number];
     debug: [msg: string | Error];
 };
 type UpdateJSON = {
@@ -16,38 +12,27 @@ type UpdateJSON = {
     size: number;
 };
 type MaybeArray<T> = T extends undefined | null | never ? [] : T extends any[] ? T['length'] extends 1 ? [data: T[0]] : T : [data: T];
-interface BaseOption {
-    /**
-     * URL of version info json
-     * @default `${repository.replace('github.com', 'raw.githubusercontent.com')}/version.json`
-     * @throws if `updateJsonURL` and `repository` are all not set
-     */
-    updateJsonURL?: string;
-    /**
-     * URL of release asar.gz
-     * @default `${repository}/releases/download/latest/${productName}.asar.gz`
-     * @throws if `releaseAsarURL` and `repository` are all not set
-     */
-    releaseAsarURL?: string;
-}
 interface TypedUpdater<T extends Record<string | symbol, MaybeArray<any>>, Event extends Exclude<keyof T, number> = Exclude<keyof T, number>> {
     removeAllListeners<E extends Event>(event?: E): this;
     listeners<E extends Event>(eventName: E): Function[];
     eventNames(): (Event)[];
     on<E extends Event>(eventName: E, listener: (...data: MaybeArray<T[E]>) => void): this;
-    once<E extends Event>(eventName: E, listener: (...args: MaybeArray<T[E]>) => void): this;
     emit<E extends Event>(eventName: E, ...args: MaybeArray<T[E]>): boolean;
     off<E extends Event>(eventName: E, listener: (...args: MaybeArray<T[E]>) => void): this;
     /**
-     * - `undefined`: errror
+     * - `{size: number, version: string}`: available
      * - `false`: unavailable
-     * - `{size: number, version: string}`: success
+     * - `Error`: fail
      */
-    checkUpdate(url?: BaseOption['updateJsonURL']): Promise<void>;
-    downloadUpdate(url?: BaseOption['releaseAsarURL'] | Buffer): Promise<void>;
+    checkUpdate(url?: string): Promise<CheckResultType>;
+    /**
+     * - `true`: success
+     * - `Error`: fail
+     */
+    downloadUpdate(url?: string | Buffer): Promise<DownloadResult>;
 }
 type Updater = TypedUpdater<UpdateEvents>;
-interface UpdaterOption extends BaseOption {
+interface UpdaterOption {
     /**
      * public key of signature
      *
@@ -65,7 +50,7 @@ interface UpdaterOption extends BaseOption {
      */
     SIGNATURE_PUB: string;
     /**
-     * product name
+     * name of your application
      *
      * you can use the `name` in `package.json`
      */
@@ -79,8 +64,29 @@ interface UpdaterOption extends BaseOption {
      * `repository` will be used to determine the url
      */
     repository?: string;
+    /**
+     * URL of version info json
+     * @default `${repository.replace('github.com', 'raw.githubusercontent.com')}/master/version.json`
+     * @throws if `updateJsonURL` and `repository` are all not set
+     */
+    updateJsonURL?: string;
+    /**
+     * URL of release asar.gz
+     * @default `${repository}/releases/download/latest/${productName}.asar.gz`
+     * @throws if `releaseAsarURL` and `repository` are all not set
+     */
+    releaseAsarURL?: string;
+    /**
+     * whether to enable debug listener
+     */
     debug?: boolean;
-    compareVersion?: (oldVersion: string, newVersion: string) => boolean;
+    /**
+     * custom version compare function
+     * @param oldVersion old version string
+     * @param newVersion new version string
+     * @returns whether to update
+     */
+    compareVersion?: (oldVersion: string, newVersion: string) => boolean | Promise<boolean>;
     downloadConfig?: {
         /**
          * download user agent
@@ -94,7 +100,7 @@ interface UpdaterOption extends BaseOption {
         /**
          * download JSON function
          * @param url download url
-         * @param updater updater, emit events
+         * @param updater updater, to trigger events
          * @param header download header
          * @returns `UpdateJSON`
          */
@@ -102,7 +108,7 @@ interface UpdaterOption extends BaseOption {
         /**
          * download buffer function
          * @param url download url
-         * @param updater updater, emit events
+         * @param updater updater, to trigger events
          * @param header download header
          * @returns `Buffer`
          */
@@ -144,61 +150,63 @@ declare function restartApp(): void;
 
 declare function createUpdater({ SIGNATURE_PUB, repository, productName, releaseAsarURL: _release, updateJsonURL: _update, debug, downloadConfig, compareVersion, }: UpdaterOption): Updater;
 
-interface AppOption {
+type AppOption = {
+    /**
+     * name of your application
+    *
+     * you can use the `name` in `package.json`
+    */
+    name: string;
     /**
      * path of electron output dist
      * @default 'dist-electron'
-     */
+    */
     electronDistPath?: string;
     /**
      * relative path of main entry in electron dist
      * @default 'main/index.js'
-     */
+    */
     mainPath?: string;
-}
+};
+type OptionalProperty<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type InitUpdaterOptions = OptionalProperty<UpdaterOption, 'productName'>;
 /**
- * Initialize application
- * @param productName name of your application
- * @param updater updater instance or updater options
- * @param option options for entry, will be used to generate electron main path, default target path: `dist-electron/main/index.js`
- * @returns a function to init your application with a updater
- *
+ * create updater manually
  * @example
- * **manual** generate updater
  * ```ts
- * import { initApp } from 'electron-incremental-updater'
+ * import { createUpdater, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL } from 'electron-incremental-update'
  * import { name, repository } from '../package.json'
  *
- * const SIGNATURE_PUB = '' // auto generate RSA public key when start app
+ * const SIGNATURE_PUB = '' // auto generate
+ *
+ * const { cdnPrefix } = getGithubReleaseCdnGroup()[0]
  * const updater = createUpdater({
  *   SIGNATURE_PUB,
  *   productName: name,
  *   repository,
+ *   updateJsonURL: parseGithubCdnURL(repository, 'fastly.jsdelivr.net/gh', 'version.json'),
+ *   releaseAsarURL: parseGithubCdnURL(repository, cdnPrefix, `download/latest/${name}.asar.gz`),
+ *   debug: true,
  * })
- * initApp(name, updater)
+ * initApp({ name }).setUpdater(updater)
  * ```
- * @example
- * **auto** generate updater and set update URL
+ */
+declare function initApp(appOptions: AppOption): {
+    setUpdater: (updater: Updater) => void;
+};
+/**
+ * create updater when init, no need to set productName
  *
+ * @example
  * ```ts
- * import { getReleaseDnsPrefix, initApp } from 'electron-incremental-update'
+ * import { initApp } from 'electron-incremental-update'
  * import { name, repository } from '../package.json'
  *
- * const SIGNATURE_PUB = '' // auto generate RSA public key when start app
+ * const SIGNATURE_PUB = '' // auto generate
  *
- * const { urlPrefix } = getReleaseCdnPrefix()[0]
- * initApp(name, {
- *   SIGNATURE_PUB,
- *   repository,
- *   updateJsonURL: `https://cdn.jsdelivr.net/gh/${repository.replace('https://github.com', '')}/version.json`,
- *   releaseAsarURL: `${urlPrefix}/download/latest/${name}.asar.gz`,
- * }, {
- *  // options for main entry
- * })
+ * initApp({ name }, { SIGNATURE_PUB, repository })
  * ```
-*/
-declare function initApp(productName: string, updater: Updater | Omit<UpdaterOption, 'productName'> & {
-    productName?: string;
-}, option?: AppOption): any;
+ */
+declare function initApp(appOptions: AppOption, updaterOptions: InitUpdaterOptions): undefined;
 
-export { BaseOption, CheckResultType, UpdateJSON, Updater, UpdaterOption, createUpdater, getAppAsarPath, getAppVersion, getEntryVersion, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL, requireNative, restartApp };
+export { AppOption, CheckResultType, DownloadResult, InitUpdaterOptions, UpdateJSON, Updater, UpdaterOption, createUpdater, getAppAsarPath, getAppVersion, getEntryVersion, getGithubReleaseCdnGroup, initApp, parseGithubCdnURL, requireNative, restartApp };

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import {
-  __require
-} from "./chunk-AKU6F3WT.mjs";
+  __require,
+  verify
+} from "./chunk-SSJ6PDMK.mjs";
 
 // src/index.ts
 import { resolve } from "node:path";
@@ -8,7 +9,6 @@ import { app as app3 } from "electron";
 
 // src/updater/index.ts
 import { EventEmitter } from "node:events";
-import { createVerify } from "node:crypto";
 import { createGunzip } from "node:zlib";
 import { createReadStream, createWriteStream, existsSync } from "node:fs";
 import { rm, writeFile } from "node:fs/promises";
@@ -25,11 +25,15 @@ function downloadJSONDefault(url, updater, headers) {
       res.headers = headers;
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
-        const json = JSON.parse(data);
-        if ("signature" in json && "version" in json && "size" in json) {
-          resolve2(json);
-        } else {
-          throw new Error("invalid update json");
+        try {
+          const json = JSON.parse(data);
+          if ("signature" in json && "version" in json && "size" in json) {
+            resolve2(json);
+          } else {
+            throw Error;
+          }
+        } catch (e) {
+          reject(new Error("invalid json"));
         }
       });
     }).on("error", (e) => {
@@ -38,12 +42,14 @@ function downloadJSONDefault(url, updater, headers) {
   });
 }
 function downloadBufferDefault(url, updater, headers) {
+  let progress = 0;
   return new Promise((resolve2, reject) => {
     https.get(url, (res) => {
       let data = [];
       res.headers = headers;
       res.on("data", (chunk) => {
-        updater.emit("downloading", chunk.length);
+        progress += chunk.length;
+        updater.emit("downloading", progress);
         data.push(chunk);
       });
       res.on("end", () => {
@@ -139,6 +145,7 @@ function createUpdater({
 }) {
   const updater = new EventEmitter();
   let signature = "";
+  let version = "";
   const gzipPath = `../${productName}.asar.gz`;
   const tmpFile = gzipPath.replace(".asar.gz", ".tmp.gz");
   const { downloadBuffer, downloadJSON, extraHeader, userAgent } = downloadConfig || {};
@@ -152,12 +159,16 @@ function createUpdater({
       UserAgent: ua,
       ...extraHeader
     };
-    log(`headers: ${headers}`);
+    log(`download headers: ${JSON.stringify(headers, null, 2)}`);
     const downloadFn = format === "json" ? downloadJSON ?? downloadJSONDefault : downloadBuffer ?? downloadBufferDefault;
-    return await downloadFn(url, updater, headers);
+    log(`download ${format} from ${url}`);
+    const ret = await downloadFn(url, updater, headers);
+    log(`download ${format} success`);
+    return ret;
   }
   async function extractFile(gzipFilePath) {
     if (!gzipFilePath.endsWith(".asar.gz") || !existsSync(gzipFilePath)) {
+      log("update .asar.gz file not exist");
       return;
     }
     gzipFilePath = gzipFilePath.replace(".asar.gz", ".tmp.gz");
@@ -169,121 +180,119 @@ function createUpdater({
       log(`outputFilePath: ${outputFilePath}`);
       input.pipe(gunzip).pipe(output).on("finish", async () => {
         await rm(gzipFilePath);
-        log("finish");
+        log(`${gzipFilePath} unzipped`);
         resolve2(outputFilePath);
       }).on("error", async (err) => {
         await rm(gzipFilePath);
-        log(`error: ${err}`);
         output.destroy(err);
         reject(err);
       });
     });
   }
-  function verify(buffer, signature2) {
-    log(`signature: ${signature2}`);
-    return createVerify("RSA-SHA256").update(buffer).verify(SIGNATURE_PUB, signature2, "base64");
-  }
-  function needUpdate(version) {
-    if (!version || !app2.isPackaged) {
+  function needUpdate(version2) {
+    if (!app2.isPackaged) {
+      log("in dev mode, no need to update");
       return false;
     }
     const currentVersion = getEntryVersion();
-    log(`currentVersion: ${currentVersion}`);
-    log(`newVersion: ${version}`);
+    log(`check update:
+    current version is ${currentVersion},
+    new version is ${version2}`);
     const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version);
-  }
-  async function checkUpdate(url) {
-    url ??= _update;
-    if (!url) {
-      log("no updateJsonURL, use repository");
-      if (!repository) {
-        throw new Error("updateJsonURL or repository are not set");
-      }
-      url = `${repository.replace("github.com", "raw.githubusercontent.com")}/version.json`;
-    }
-    log(`updateJsonURL: ${url}`);
-    if (existsSync(tmpFile)) {
-      log(`remove tmp file: ${tmpFile}`);
-      await rm(tmpFile);
-    }
-    const json = await download(url, "json");
-    const {
-      signature: _sig,
-      version,
-      size
-    } = json;
-    log(`UpdateJSON: ${JSON.stringify(json, null, 2)}`);
-    if (!needUpdate(version)) {
-      return false;
-    } else {
-      signature = _sig;
-      return { size, version };
-    }
+    return _compare(currentVersion, version2);
   }
-  async function downloadUpdate(src) {
-    if (typeof src !== "object") {
-      let _url = src ?? _release;
-      if (!_url) {
-        log("no releaseAsarURL, use repository");
+  updater.checkUpdate = async (url) => {
+    try {
+      url ??= _update;
+      if (!url) {
+        log("no updateJsonURL, fallback to use repository");
         if (!repository) {
-          throw new Error("releaseAsarURL or repository are not set");
+          throw new Error("updateJsonURL or repository are not set");
         }
-        _url = `${repository}/releases/download/latest/${productName}.asar.gz`;
+        url = `${repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`;
+      }
+      if (existsSync(tmpFile)) {
+        log(`remove tmp file: ${tmpFile}`);
+        await rm(tmpFile);
+      }
+      if (existsSync(gzipPath)) {
+        log(`remove .gz file: ${gzipPath}`);
+        await rm(gzipPath);
+      }
+      const json = await download(url, "json");
+      const {
+        signature: _sig,
+        version: _v,
+        size
+      } = json;
+      log(`update info: ${JSON.stringify(json, null, 2)}`);
+      if (!await needUpdate(_v)) {
+        log(`update unavailable: ${_v}`);
+        return void 0;
+      } else {
+        log(`update available: ${_v}`);
+        signature = _sig;
+        version = _v;
+        return { size, version };
       }
-      log(`releaseAsarURL: ${_url}`);
-      src = await download(_url, "buffer");
-    }
-    log("start verify");
-    if (!verify(src, signature)) {
-      throw new Error("file broken, invalid signature!");
-    }
-    log(`write file: ${gzipPath}`);
-    await writeFile(gzipPath, src);
-    log(`extract file: ${gzipPath}`);
-    await extractFile(gzipPath);
-    updater.emit("downloaded");
-  }
-  const onCheck = async (url) => {
-    try {
-      const result = await checkUpdate(url);
-      updater.emit("checkResult", result);
     } catch (error) {
       log(error);
-      updater.emit("checkResult", error);
+      return error;
     }
   };
-  updater.on("check", onCheck);
-  updater.checkUpdate = onCheck;
-  const onDownload = async (src) => {
+  updater.downloadUpdate = async (src) => {
     try {
-      await downloadUpdate(src);
+      if (typeof src !== "object") {
+        let _url = src ?? _release;
+        if (!_url) {
+          log("no releaseAsarURL, fallback to use repository");
+          if (!repository) {
+            throw new Error("releaseAsarURL or repository are not set");
+          }
+          _url = `${repository}/releases/download/latest/${productName}.asar.gz`;
+        }
+        src = await download(_url, "buffer");
+      }
+      log("verify start");
+      if (!verify(src, signature, SIGNATURE_PUB, productName)) {
+        log("verify failed");
+        throw new Error("invalid signature");
+      }
+      log("verify success");
+      log(`write file: ${gzipPath}`);
+      await writeFile(gzipPath, src);
+      log(`extract file: ${gzipPath}`);
+      await extractFile(gzipPath);
+      log(`update success, version: ${version}`);
+      return true;
     } catch (error) {
       log(error);
-      updater.emit("donwnloadError", error);
+      return error;
     }
   };
-  updater.on("download", onDownload);
-  updater.downloadUpdate = onDownload;
   return updater;
 }
 
 // src/index.ts
-function initApp(productName, updater, option) {
+function initApp(appOptions, updaterOptions) {
   const {
+    name: productName,
     electronDistPath = "dist-electron",
     mainPath = "main/index.js"
-  } = option ?? {};
+  } = appOptions ?? {};
   const mainDir = app3.isPackaged ? `../${productName}.asar` : electronDistPath;
   const entry = resolve(__dirname, mainDir, mainPath);
-  let _updater;
-  if ("SIGNATURE_PUB" in updater) {
-    const _option = updater.productName ? updater : { ...updater, productName };
-    _updater = createUpdater(_option);
+  if (updaterOptions) {
+    __require(entry)(
+      createUpdater({ ...updaterOptions, productName })
+    );
   } else {
-    _updater = updater;
+    return {
+      setUpdater(updater) {
+        __require(entry)(updater);
+      }
+    };
   }
-  return __require(entry)(_updater);
 }
 export {
   createUpdater,