electron-incremental-update 1.1.0 → 1.3.0

package/dist/index.cjs

@@ -20,12 +20,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  DownloadError: () => DownloadError,
-  MinimumVersionError: () => MinimumVersionError,
+  ErrorInfo: () => ErrorInfo,
   Updater: () => Updater,
-  VerifyFailedError: () => VerifyFailedError,
+  UpdaterError: () => UpdaterError,
   createUpdater: () => createUpdater,
+  downloadBufferDefault: () => downloadBufferDefault,
+  downloadJSONDefault: () => downloadJSONDefault,
   initApp: () => initApp,
+  isLowerVersionDefault: () => isLowerVersionDefault,
   startupWithUpdater: () => startupWithUpdater
 });
 module.exports = __toCommonJS(src_exports);
@@ -35,7 +37,6 @@ var import_electron4 = require("electron");
 
 // src/updater/core.ts
 var import_node_fs3 = require("fs");
-var import_promises = require("fs/promises");
 var import_electron3 = require("electron");
 
 // src/utils/electron.ts
@@ -87,7 +88,7 @@ async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
   }
   const compressedBuffer = (0, import_node_fs2.readFileSync)(gzipPath);
   return new Promise((resolve2, reject) => {
-    (0, import_node_zlib.gunzip)(compressedBuffer, (err, buffer) => {
+    (0, import_node_zlib.brotliDecompress)(compressedBuffer, (err, buffer) => {
       (0, import_node_fs2.rmSync)(gzipPath);
       if (err) {
         reject(err);
@@ -100,8 +101,7 @@ async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
 
 // src/utils/pure.ts
 function parseVersion(version) {
-  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i;
-  const match = semver.exec(version);
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i.exec(version);
   if (!match) {
     throw new TypeError(`invalid version: ${version}`);
   }
@@ -159,100 +159,67 @@ var verify = (buffer, signature, cert) => {
 var import_node_crypto3 = require("crypto");
 
 // src/updater/types.ts
-var MinimumVersionError = class extends Error {
-  currentVersion;
-  minVersion;
-  constructor(version, minimumVersion) {
-    super(`current entry version is ${version}, less than the minimumVersion ${minimumVersion}`);
-    this.currentVersion = version;
-    this.minVersion = minimumVersion;
-  }
-};
-var VerifyFailedError = class extends Error {
-  signature;
-  cert;
-  constructor(signature, cert) {
-    super("verify failed, invalid signature or certificate");
-    this.signature = signature;
-    this.cert = cert;
-  }
+var ErrorInfo = {
+  downlaod: "Download failed",
+  validate: "Validate failed",
+  param: "Missing params",
+  version: "Unsatisfied version"
 };
-var DownloadError = class extends Error {
-  constructor(msg) {
-    super(`download update error, ${msg}`);
+var UpdaterError = class extends Error {
+  constructor(msg, info) {
+    super(msg + ": " + info);
   }
 };
 
 // src/updater/defaultFunctions/download.ts
 var import_electron2 = require("electron");
-var downloadJSONDefault = async (url, headers) => {
+async function downlaodFn(url, headers, onResponse) {
   await waitAppReady();
   return new Promise((resolve2, reject) => {
-    const request = import_electron2.net.request({
-      url,
-      method: "GET",
-      redirect: "follow"
-    });
-    Object.keys(headers).forEach((key) => {
-      request.setHeader(key, headers[key]);
-    });
-    request.on("response", (res) => {
-      let data = "";
-      res.on("data", (chunk) => data += chunk);
-      res.on("end", () => {
-        try {
-          const json = JSON.parse(data);
-          if (isUpdateJSON(json)) {
-            resolve2(json);
-          } else {
-            throw Error;
-          }
-        } catch (e) {
-          reject(new Error("invalid json"));
+    const request = import_electron2.net.request({ url, method: "GET", redirect: "follow" });
+    Object.keys(headers).forEach((key) => request.setHeader(key, headers[key]));
+    request.on("response", (res) => onResponse(res, resolve2, reject));
+    request.on("error", reject);
+    request.end();
+  });
+}
+var downloadJSONDefault = async (url, headers) => {
+  return await downlaodFn(url, headers, (resp, resolve2, reject) => {
+    let data = "";
+    resp.on("data", (chunk) => data += chunk);
+    resp.on("end", () => {
+      try {
+        const json = JSON.parse(data);
+        if (isUpdateJSON(json)) {
+          resolve2(json);
+        } else {
+          throw Error;
         }
-      });
-    });
-    request.on("error", (e) => {
-      reject(e);
+      } catch (ignore) {
+        reject(new Error("invalid update json"));
+      }
     });
-    request.end();
+    resp.on("aborted", () => reject(new Error("aborted")));
+    resp.on("error", () => reject(new Error("download error")));
   });
 };
 var downloadBufferDefault = async (url, headers, total, onDownloading) => {
-  await waitAppReady();
   let current = 0;
-  return new Promise((resolve2, reject) => {
-    const request = import_electron2.net.request({
-      url,
-      method: "GET",
-      redirect: "follow"
+  return await downlaodFn(url, headers, (resp, resolve2, reject) => {
+    let data = [];
+    resp.on("data", (chunk) => {
+      current += chunk.length;
+      onDownloading?.({ percent: `${+(current / total).toFixed(2) * 100}%`, total, current });
+      data.push(chunk);
     });
-    Object.keys(headers).forEach((key) => {
-      request.setHeader(key, headers[key]);
-    });
-    request.on("response", (res) => {
-      let data = [];
-      res.on("data", (chunk) => {
-        current += chunk.length;
-        onDownloading?.({
-          percent: `${+(current / total).toFixed(2) * 100}%`,
-          total,
-          current
-        });
-        data.push(chunk);
-      });
-      res.on("end", () => {
-        resolve2(Buffer.concat(data));
-      });
-    }).on("error", (e) => {
-      reject(e);
-    });
-    request.end();
+    resp.on("end", () => resolve2(Buffer.concat(data)));
+    resp.on("aborted", () => reject(new Error("aborted")));
+    resp.on("error", () => reject(new Error("download error")));
   });
 };
 
 // src/updater/defaultFunctions/compareVersion.ts
-var compareVersionDefault = (version1, version2) => {
+var isLowerVersionDefault = (version1, version2) => {
   const oldV = parseVersion(version1);
   const newV = parseVersion(version2);
   function compareStrings(str1, str2) {
@@ -275,6 +242,7 @@ var compareVersionDefault = (version1, version2) => {
 
 // src/updater/core.ts
 var Updater = class {
+  CERT = __SIGNATURE_CERT__;
   info;
   option;
   asarPath;
@@ -306,38 +274,39 @@ var Updater = class {
    * initialize incremental updater
    * @param option UpdaterOption
    */
-  constructor(option) {
+  constructor(option = {}) {
     this.option = option;
+    if (option.SIGNATURE_CERT) {
+      this.CERT = option.SIGNATURE_CERT;
+    }
     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 isLowerVersion = this.option.overrideFunctions?.isLowerVersion ?? isLowerVersionDefault;
     const { appVersion, entryVersion } = getVersions();
-    if (await compare(entryVersion, minVersion)) {
-      throw new MinimumVersionError(entryVersion, minVersion);
+    if (await isLowerVersion(entryVersion, minVersion)) {
+      throw new UpdaterError(ErrorInfo.version, `entry version (${entryVersion}) < minimumVersion (${minVersion})`);
     }
     this.logger?.info(`check update: current version is ${appVersion}, new version is ${version}`);
-    return await compare(appVersion, version);
+    return await isLowerVersion(appVersion, version);
   }
   async parseData(format, data) {
     if ((0, import_node_fs3.existsSync)(this.tmpFilePath)) {
       this.logger?.warn(`remove tmp file: ${this.tmpFilePath}`);
-      await (0, import_promises.rm)(this.tmpFilePath);
+      (0, import_node_fs3.rmSync)(this.tmpFilePath);
     }
     if ((0, import_node_fs3.existsSync)(this.gzipPath)) {
       this.logger?.warn(`remove .gz file: ${this.gzipPath}`);
-      await (0, import_promises.rm)(this.gzipPath);
-    }
-    if (!["string", "object", "undefined"].includes(typeof data)) {
-      throw new TypeError(`invalid type at format '${format}': ${data}`);
-    }
-    if (typeof data === "object" && (format === "json" && isUpdateJSON(data) || format === "buffer" && Buffer.isBuffer(data))) {
-      return data;
+      (0, import_node_fs3.rmSync)(this.gzipPath);
     }
     if (typeof data === "object") {
-      throw new TypeError(`invalid type at format '${format}': ${data}`);
+      if (format === "json" && isUpdateJSON(data) || format === "buffer" && Buffer.isBuffer(data)) {
+        return data;
+      } else {
+        throw new UpdaterError(ErrorInfo.param, `invalid type at format '${format}': ${JSON.stringify(data)}`);
+      }
     }
     const ua = this.option.downloadConfig?.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
     const headers = {
@@ -345,11 +314,11 @@ var Updater = class {
       UserAgent: ua,
       ...this.option.downloadConfig?.extraHeader
     };
-    this.logger?.info(`download headers: ${JSON.stringify(headers, null, 2)}`);
+    this.logger?.debug(`download headers: ${JSON.stringify(headers)}`);
     const config = format === "json" ? {
       name: "updateJsonURL",
       url: this.option.updateJsonURL,
-      repoFallback: `${this.option.repository.replace("github.com", "raw.githubusercontent.com")}/master/version.json`,
+      repoFallback: `${this.option.repository?.replace("github.com", "raw.githubusercontent.com")}/master/version.json`,
       fn: this.option.overrideFunctions?.downloadJSON ?? downloadJSONDefault
     } : {
       name: "releaseAsarURL",
@@ -361,32 +330,22 @@ var Updater = class {
     if (!data) {
       this.logger?.debug(`no ${config.name}, fallback to use repository`);
       if (!this.option.repository) {
-        throw new Error(`${config.name} or repository are not set`);
+        throw new UpdaterError(ErrorInfo.param, `${config.name} or repository is not set`);
       }
       if (format === "buffer" && !this.info?.version) {
-        throw new Error("version are not set");
+        throw new UpdaterError(ErrorInfo.param, "version is not set");
       }
       data = config.repoFallback;
     }
-    this.logger?.info(`download ${format} from ${data}`);
+    this.logger?.debug(`download ${format} from ${data}`);
     try {
       const ret = format === "json" ? await config.fn(data, headers) : await config.fn(data, headers, this.info.size, this.onDownloading);
-      this.logger?.info(`download ${format} success${format === "buffer" ? `, file size: ${ret.length}` : ""}`);
+      this.logger?.debug(`download ${format} success${format === "buffer" ? `, file size: ${ret.length}` : ""}`);
       return ret;
     } catch (e) {
-      throw new DownloadError(e.toString());
+      throw new UpdaterError(ErrorInfo.downlaod, 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);
@@ -396,7 +355,7 @@ var Updater = class {
         minimumVersion = beta.minimumVersion;
         size = beta.size;
       }
-      this.logger?.info(`checked version: ${version}, size: ${size}, signature: ${signature}`);
+      this.logger?.debug(`checked version: ${version}, size: ${size}, signature: ${signature}`);
       if (!await this.needUpdate(version, minimumVersion)) {
         this.logger?.info(`update unavailable: ${version} is the latest version`);
         return void 0;
@@ -415,33 +374,23 @@ var Updater = class {
       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;
       if (!_sig) {
-        throw new Error("signature are not set, please checkUpdate first or set the second parameter");
+        throw new UpdaterError(ErrorInfo.param, "signature is empty");
       }
       const buffer = await this.parseData("buffer", data);
-      this.logger?.info("verify start");
+      this.logger?.debug("verify start");
       const _verify = this.option.overrideFunctions?.verifySignaure ?? verify;
-      const _ver = await _verify(buffer, _sig, this.option.SIGNATURE_CERT);
+      const _ver = await _verify(buffer, _sig, this.CERT);
       if (!_ver) {
-        throw new VerifyFailedError(_sig, this.option.SIGNATURE_CERT);
+        throw new UpdaterError(ErrorInfo.validate, "invalid signature or certificate");
       }
-      this.logger?.info("verify success");
-      this.logger?.info(`write to ${this.gzipPath}`);
-      await (0, import_promises.writeFile)(this.gzipPath, buffer);
-      this.logger?.info(`extract to ${this.tmpFilePath}`);
+      this.logger?.debug("verify success");
+      this.logger?.debug(`write to ${this.gzipPath}`);
+      (0, import_node_fs3.writeFileSync)(this.gzipPath, buffer);
+      this.logger?.debug(`extract to ${this.tmpFilePath}`);
       await unzipFile(this.gzipPath, this.tmpFilePath);
       this.logger?.info(`download success, version: ${_ver}`);
       this.info = void 0;
@@ -473,8 +422,9 @@ var defaultOnInstall = (install, _, __, logger) => {
   install();
   logger?.info(`update success!`);
 };
-function initApp(appOptions) {
+async function initApp(appOptions = {}) {
   const {
+    updater,
     electronDevDistPath = "../dist-electron",
     mainPath = "main/index.js",
     hooks
@@ -484,51 +434,42 @@ function initApp(appOptions) {
     beforeStart,
     onStartError
   } = hooks || {};
-  function handleError(err, logger) {
+  function handleError(err, logger2) {
     console.error(err);
-    onStartError?.(err, logger);
+    onStartError?.(err, logger2);
     import_electron4.app.quit();
   }
-  async function startup(updater) {
-    const logger = updater.logger;
-    try {
-      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 = is.dev ? electronDevDistPath : appNameAsarPath;
-      const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
-      await beforeStart?.(entry, logger);
-      require(entry)(updater);
-    } catch (error) {
-      handleError(error, logger);
-    }
+  let updaterInstance;
+  if (typeof updater === "object" || !updater) {
+    updaterInstance = createUpdater(updater);
+  } else {
+    updaterInstance = await updater();
   }
-  let timer = setTimeout(() => {
-    handleError("start app timeout, please start app with `initApp(options).startupWithUpdater(options)`");
-  }, 3e3);
-  return {
-    async startupWithUpdater(updater) {
-      clearTimeout(timer);
-      if (typeof updater === "object") {
-        await startup(createUpdater(updater));
-      } else if (typeof updater === "function") {
-        await startup(await updater());
-      } else {
-        handleError("invalid updater option or updater is not a function");
-      }
+  const logger = updaterInstance.logger;
+  try {
+    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 = is.dev ? electronDevDistPath : appNameAsarPath;
+    const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
+    await beforeStart?.(entry, logger);
+    require(entry)(updaterInstance);
+  } catch (error) {
+    handleError(error, logger);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DownloadError,
-  MinimumVersionError,
+  ErrorInfo,
   Updater,
-  VerifyFailedError,
+  UpdaterError,
   createUpdater,
+  downloadBufferDefault,
+  downloadJSONDefault,
   initApp,
+  isLowerVersionDefault,
   startupWithUpdater
 });

package/dist/index.d.cts

@@ -1,22 +1,16 @@
 import { U as UpdateInfo, a as UpdateJSON } from './pure-GoN_3MEj.cjs';
 
-declare class MinimumVersionError extends Error {
-    currentVersion: string;
-    minVersion: string;
-    constructor(version: string, minimumVersion: string);
-}
-declare class VerifyFailedError extends Error {
-    signature: string;
-    cert: string;
-    constructor(signature: string, cert: string);
-}
-declare class DownloadError extends Error {
-    constructor(msg: string);
+declare const ErrorInfo: {
+    readonly downlaod: "Download failed";
+    readonly validate: "Validate failed";
+    readonly param: "Missing params";
+    readonly version: "Unsatisfied version";
+};
+declare class UpdaterError extends Error {
+    constructor(msg: typeof ErrorInfo[keyof typeof ErrorInfo], info: string);
 }
-type CheckResult = UpdateInfo | undefined | CheckResultError;
-type CheckResultError = MinimumVersionError | DownloadError | TypeError | Error;
-type DownloadResult = true | DownloadResultError;
-type DownloadResultError = DownloadError | VerifyFailedError | TypeError | Error;
+type CheckResult = UpdateInfo | undefined | UpdaterError;
+type DownloadResult = true | UpdaterError;
 type DownloadingInfo = {
     /**
      * downloaded percent, 0% - 100%
@@ -42,9 +36,9 @@ type UpdaterOverrideFunctions = {
      * custom version compare function
      * @param version1 old version string
      * @param version2 new version string
-     * @returns whether version1 < version2
+     * @returns if version1 < version2
      */
-    compareVersion?: (version1: string, version2: string) => boolean | Promise<boolean>;
+    isLowerVersion?: (version1: string, version2: string) => boolean | Promise<boolean>;
     /**
      * custom verify signature function
      * @param buffer file buffer
@@ -83,19 +77,10 @@ type UpdaterDownloadConfig = {
 };
 interface UpdaterOption {
     /**
-     * public key of signature, which will be auto generated by plugin
-     * @example
-     * ```ts
-     * // just empty here, auto filled by plugin
-     * const SIGNATURE_CERT = ''
-     *
-     * const updater = createUpdater({
-     *   SIGNATURE_CERT,
-     *   ...
-     * })
-     * ```
+     * public key of signature, which will be auto generated by plugin,
+     * generate by `selfsigned` if not set
      */
-    SIGNATURE_CERT: string;
+    SIGNATURE_CERT?: string;
     /**
      * repository url, e.g. `https://github.com/electron/electron`
      *
@@ -126,6 +111,7 @@ interface UpdaterOption {
 }
 
 declare class Updater {
+    private CERT;
     private info?;
     private option;
     private asarPath;
@@ -153,7 +139,7 @@ declare class Updater {
      * initialize incremental updater
      * @param option UpdaterOption
      */
-    constructor(option: UpdaterOption);
+    constructor(option?: UpdaterOption);
     private needUpdate;
     /**
      * this function is used to parse download data.
@@ -168,43 +154,81 @@ declare class Updater {
      */
     private parseData;
     /**
-     * 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
+     * check update info using default options
+     * @returns
+     * - Available: `{size: number, version: string}`
+     * - Unavailable: `undefined`
+     * - Fail: `UpdaterError`
+     */
+    checkUpdate(): Promise<CheckResult>;
+    /**
+     * check update info using custom url
+     * @param url custom download URL of `updatejson`
      * @returns
      * - Available:`{size: number, version: string}`
      * - Unavailable: `undefined`
-     * - Fail: `CheckResultError`
+     * - Fail: `UpdaterError`
      */
-    checkUpdate(data?: string | UpdateJSON): Promise<CheckResult>;
+    checkUpdate(url: string): Promise<CheckResult>;
     /**
-     * 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
+     * check update info using existing update json
+     * @param data existing update json
+     * @returns
+     * - Available:`{size: number, version: string}`
+     * - Unavailable: `undefined`
+     * - Fail: `UpdaterError`
+     */
+    checkUpdate(data: UpdateJSON): Promise<CheckResult>;
+    /**
+     * download update using default options
+     * @returns
+     * - Success: `true`
+     * - Fail: `UpdaterError`
+     */
+    download(): Promise<DownloadResult>;
+    /**
+     * download update using custom url
+     * @param url custom download URL
+     * @returns
+     * - Success: `true`
+     * - Fail: `UpdaterError`
+     */
+    download(url: string): Promise<DownloadResult>;
+    /**
+     * download update using existing `asar.gz` buffer and signature
+     * @param data existing `asar.gz` buffer
      * @param sig signature
      * @returns
-     * - `true`: success
-     * - `DownloadResultError`: fail
+     * - Success: `true`
+     * - Fail: `UpdaterError`
      */
-    download(data?: Buffer, sig?: string): Promise<DownloadResult>;
+    download(data: Buffer, sig: string): Promise<DownloadResult>;
     /**
      * quit App and install
      */
     quitAndInstall(): void;
 }
 
+type Func = Required<UpdaterOverrideFunctions>;
+declare const downloadJSONDefault: Func['downloadJSON'];
+declare const downloadBufferDefault: Func['downloadBuffer'];
+
+declare const isLowerVersionDefault: Func['isLowerVersion'];
+
 /**
  * create updater instance
  * @param option updater option
  * @returns updater
  */
-declare function createUpdater(option: UpdaterOption): Updater;
+declare function createUpdater(option?: UpdaterOption): Updater;
 
 type Promisable<T> = T | Promise<T>;
 type OnInstallFunction = (install: VoidFunction, tempAsarPath: string, appNameAsarPath: string, logger?: Logger) => Promisable<void>;
 type AppOption = {
+    /**
+     * updater options
+     */
+    updater?: (() => Promisable<Updater>) | UpdaterOption;
     /**
      * path of electron output dist when in development
      * @default '../dist-electron'
@@ -252,13 +276,6 @@ type AppOption = {
  * })
  */
 declare function startupWithUpdater(fn: (updater: Updater) => Promisable<void>): (updater: Updater) => Promisable<void>;
-type StartupWithUpdater = {
-    /**
-     * starup app
-     * @param updater updater option or create function
-     */
-    startupWithUpdater: (updater: (() => Promisable<Updater>) | UpdaterOption) => void;
-};
 /**
  * initialize app
  * @example
@@ -266,20 +283,22 @@ type StartupWithUpdater = {
  * import { getGithubReleaseCdnGroup, initApp, parseGithubCdnURL } from 'electron-incremental-update'
  * import { repository } from '../package.json'
  *
- * const SIGNATURE_CERT = '' // auto generate certificate when start app
  * const { cdnPrefix: asarPrefix } = getGithubReleaseCdnGroup()[0]
  * const { cdnPrefix: jsonPrefix } = getGithubFileCdnGroup()[0]
- * initApp({ onStart: console.log })
+ *
+ * initApp({
  *   // can be updater option or function that return updater
- *   .startupWithUpdater({
- *     SIGNATURE_CERT,
+ *   updater: {
+ *     SIGNATURE_CERT: 'custom certificate',
  *     repository,
  *     updateJsonURL: parseGithubCdnURL(repository, jsonPrefix, 'version.json'),
  *     releaseAsarURL: parseGithubCdnURL(repository, asarPrefix, `download/latest/${app.name}.asar.gz`),
  *     receiveBeta: true,
- *   })
+ *   },
+ *   onStart: console.log
+ * })
  * ```
  */
-declare function initApp(appOptions?: AppOption): StartupWithUpdater;
+declare function initApp(appOptions?: AppOption): Promise<void>;
 
-export { type AppOption, type CheckResult, type CheckResultError, DownloadError, type DownloadResult, type DownloadResultError, type DownloadingInfo, type Logger, MinimumVersionError, Updater, type UpdaterDownloadConfig, type UpdaterOption, type UpdaterOverrideFunctions, VerifyFailedError, createUpdater, initApp, startupWithUpdater };
+export { type AppOption, type CheckResult, type DownloadResult, type DownloadingInfo, ErrorInfo, type Func, type Logger, Updater, type UpdaterDownloadConfig, UpdaterError, type UpdaterOption, type UpdaterOverrideFunctions, createUpdater, downloadBufferDefault, downloadJSONDefault, initApp, isLowerVersionDefault, startupWithUpdater };