electron-incremental-update 2.0.0-beta.9 → 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

@@ -8,6 +8,7 @@ var path = require('path');
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 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, {
@@ -27,53 +28,54 @@ 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/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/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
+   * Initialize incremental updater
    * @param options UpdaterOption
    */
   constructor(options = {}) {
@@ -82,6 +84,7 @@ var Updater = class extends events.EventEmitter {
     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),
@@ -89,15 +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("No update provider, please setup provider before checking update");
-    }
-  }
-  checkProvider() {
-    if (!this.provider) {
-      throw new UpdaterError("param", "missing update provider");
+      this.logger?.debug("WARN: No update provider");
     }
   }
   async fetch(format, data) {
@@ -105,92 +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) {
-    this.checkProvider();
-    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) {
-    this.checkProvider();
     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;
     }
   }
@@ -198,12 +203,21 @@ var Updater = class extends events.EventEmitter {
    * quit App and install
    */
   quitAndInstall() {
-    this.logger?.info("quit and install");
+    this.logger?.info("Quit and install");
     restartApp();
   }
+  cancel() {
+    if (this.controller.signal.aborted) {
+      return;
+    }
+    this.controller.abort();
+    this.logger?.info("Cancel update");
+    this.emit("update-cancelled");
+    this.controller = new AbortController();
+  }
 };
 async function autoUpdate(updater) {
-  if (await updater.checkUpdate() && await updater.downloadUpdate()) {
+  if (await updater.checkForUpdates() && await updater.downloadUpdate()) {
     updater.quitAndInstall();
   }
 }
@@ -214,8 +228,14 @@ var defaultOnInstall = (install, _, __, logger) => {
   install();
   logger?.info(`update success!`);
 };
-async function initApp(appOptions) {
+async function createElectronApp(appOptions = {}) {
+  const appNameAsarPath = getPathFromAppNameAsar();
   const {
+    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,
@@ -229,29 +249,29 @@ async function initApp(appOptions) {
   }
   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;

package/dist/index.d.cts

@@ -1,37 +1,18 @@
 import { EventEmitter } from 'node:events';
-import { U as UpdateJSON, a as UpdateInfo } from './version-DgfjJQUx.cjs';
-import { I as IProvider, D as DownloadingInfo } from './types-mEfMjnlV.cjs';
-import '@subframe7536/type-utils';
+import { U as UpdateInfo, a as UpdateJSON } from './version-BYVQ367i.cjs';
+import { I as IProvider, D as DownloadingInfo } from './types-DkCn03M3.cjs';
+import { Promisable } from '@subframe7536/type-utils';
 
 declare const ErrorInfo: {
-    readonly download: "Download failed";
-    readonly validate: "Validate failed";
-    readonly param: "Missing params";
-    readonly network: "Network error";
+    readonly download: "Download Failed";
+    readonly validate: "Validate Failed";
+    readonly param: "Missing Params";
+    readonly network: "Network Error";
 };
 declare class UpdaterError extends Error {
     code: keyof typeof ErrorInfo;
     constructor(msg: keyof typeof ErrorInfo, info: string);
 }
-type CheckResult<T extends UpdateJSON> = {
-    success: true;
-    data: Omit<T, 'beta'>;
-} | {
-    success: false;
-    /**
-     * minimal version that can update
-     */
-    data: string;
-} | {
-    success: false;
-    data: UpdaterError;
-};
-type DownloadResult = {
-    success: true;
-} | {
-    success: false;
-    data: UpdaterError;
-};
 interface Logger {
     info: (msg: string) => void;
     debug: (msg: string) => void;
@@ -40,81 +21,82 @@ interface Logger {
 }
 interface UpdaterOption {
     /**
-     * update provider
+     * Update provider
+     *
+     * If you will not setup `UpdateJSON` or `Buffer` in params when checking update or download, this option is **required**
      */
     provider?: IProvider;
     /**
-     * public key of signature, which will be auto generated by plugin,
+     * Certifaction key of signature, which will be auto generated by plugin,
      * generate by `selfsigned` if not set
      */
     SIGNATURE_CERT?: string;
     /**
-     * whether to receive beta update
+     * Whether to receive beta update
      */
     receiveBeta?: boolean;
+    /**
+     * Updater logger
+     */
     logger?: Logger;
 }
 
 declare class Updater extends EventEmitter<{
     'checking': any;
     'update-available': [data: UpdateInfo];
-    'update-unavailable': [reason: string];
+    'update-not-available': [reason: string, data?: UpdateInfo];
     'error': [error: UpdaterError];
     'download-progress': [info: DownloadingInfo];
     'update-downloaded': any;
+    'update-cancelled': any;
 }> {
     private CERT;
+    private controller;
     private info?;
     provider?: IProvider;
     /**
-     * updater logger
+     * Updater logger
      */
     logger?: Logger;
     /**
-     * whether to receive beta update
+     * Whether to receive beta update
      */
     receiveBeta?: boolean;
     /**
-     * whether force update in DEV
+     * Whether force update in DEV
      */
     forceUpdate?: boolean;
     /**
-     * initialize incremental updater
+     * Initialize incremental updater
      * @param options UpdaterOption
      */
     constructor(options?: UpdaterOption);
-    private checkProvider;
-    /**
-     * this function is used to parse download data.
-     * - if format is `'json'`
-     *   - if data is `UpdateJSON`, return it
-     *   - if data is string or absent, download URL data and return it
-     * - if format is `'buffer'`
-     *   - if data is `Buffer`, return it
-     *   - if data is string or absent, download URL data and return it
-     * @param format 'json' or 'buffer'
-     * @param data download URL or update json or buffer
+    /**
+     * This function is used to parse download data.
+     *
+     * if data is absent, download URL from provider and return it,
+     * else if data is `UpdateJSON`, return it
      */
     private fetch;
     /**
-     * handle error message and emit error event
+     * Handle error message and emit error event
      */
     private err;
     /**
-     * check update info using default options
+     * Check update info using default options
      */
-    checkUpdate(): Promise<boolean>;
+    checkForUpdates(): Promise<boolean>;
     /**
-     * check update info using existing update json
+     * Check update info using existing update json
      * @param data existing update json
      */
-    checkUpdate(data: UpdateJSON): Promise<boolean>;
+    checkForUpdates(data: UpdateJSON): Promise<boolean>;
     /**
-     * download update using default options
+     * Download update using default options
      */
     downloadUpdate(): Promise<boolean>;
     /**
-     * download update using existing `asar.gz` buffer and signature
+     * Download update using existing `asar.gz` buffer and signature
      * @param data existing `asar.gz` buffer
      * @param info update info
      */
@@ -123,46 +105,52 @@ declare class Updater extends EventEmitter<{
      * quit App and install
      */
     quitAndInstall(): void;
+    cancel(): void;
 }
 /**
- * auto check update, download and install
+ * Auto check update, download and install
  */
 declare function autoUpdate(updater: Updater): Promise<void>;
 
-type Promisable<T> = T | Promise<T>;
 /**
- * hooks on rename temp asar path to `${app.name}.asar`
+ * Hooks on rename temp asar path to `${app.name}.asar`
  * @param install `() => renameSync(tempAsarPath, appNameAsarPath)`
  * @param tempAsarPath temp(updated) asar path
  * @param appNameAsarPath `${app.name}.asar` path
  * @param logger logger
- * @default install(); logger.info(`update success!`)
+ * @default install(); logger.info('update success!')
  */
 type OnInstallFunction = (install: VoidFunction, tempAsarPath: string, appNameAsarPath: string, logger?: Logger) => Promisable<void>;
 interface AppOption {
     /**
-     * updater options
+     * Path to index file that make {@link startupWithUpdater} as default export
+     *
+     * Generate from plugin configuration by default
+     */
+    mainPath?: string;
+    /**
+     * Updater options
      */
     updater?: (() => Promisable<Updater>) | UpdaterOption;
     /**
-     * hooks on rename temp asar path to `${app.name}.asar`
+     * Hooks on rename temp asar path to `${app.name}.asar`
      */
     onInstall?: OnInstallFunction;
     /**
-     * hooks before app start up
+     * Hooks before app startup
      * @param mainFilePath main file path of `${app.name}.asar`
      * @param logger logger
      */
     beforeStart?: (mainFilePath: string, logger?: Logger) => Promisable<void>;
     /**
-     * hooks on app start up error
+     * Hooks on app startup error
      * @param err installing or startup error
      * @param logger logger
      */
     onStartError?: (err: unknown, logger?: Logger) => void;
 }
 /**
- * utils for startuping with updater
+ * Utils to startup with updater
  * @param fn startup function
  * @example
  * // in electron/main/index.ts
@@ -172,28 +160,24 @@ interface AppOption {
  */
 declare function startupWithUpdater(fn: (updater: Updater) => Promisable<void>): (updater: Updater) => Promisable<void>;
 /**
- * initialize app
+ * Initialize Electron with updater
  * @example
- * ```ts
- * import { getGithubReleaseCdnGroup, initApp, parseGithubCdnURL } from 'electron-incremental-update'
- * import { repository } from '../package.json'
- *
- * const { cdnPrefix: asarPrefix } = getGithubReleaseCdnGroup()[0]
- * const { cdnPrefix: jsonPrefix } = getGithubFileCdnGroup()[0]
- *
- * initApp({
- *   // can be updater option or function that return updater
+ * createElectronApp({
  *   updater: {
- *     SIGNATURE_CERT: 'custom certificate',
- *     repository,
- *     updateJsonURL: parseGithubCdnURL(repository, jsonPrefix, 'version.json'),
- *     releaseAsarURL: parseGithubCdnURL(repository, asarPrefix, `download/latest/${app.name}.asar.gz`),
- *     receiveBeta: true,
+ *     provider: new GitHubProvider({
+ *       username: 'yourname',
+ *       repo: 'electron',
+ *     }),
+ *   },
+ *   beforeStart(mainFilePath, logger) {
+ *     logger?.debug(mainFilePath)
  *   },
- *   onStart: console.log
  * })
- * ```
  */
-declare function initApp(appOptions: AppOption): Promise<void>;
+declare function createElectronApp(appOptions?: AppOption): Promise<void>;
+/**
+ * @alias {@link createElectronApp}
+ */
+declare const initApp: typeof createElectronApp;
 
-export { type AppOption, type CheckResult, type DownloadResult, ErrorInfo, type Logger, Updater, UpdaterError, type UpdaterOption, autoUpdate, initApp, startupWithUpdater };
+export { type AppOption, ErrorInfo, type Logger, Updater, UpdaterError, type UpdaterOption, autoUpdate, createElectronApp, initApp, startupWithUpdater };