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

package/dist/provider.cjs

@@ -5,6 +5,11 @@ var electron = require('electron');
 var crypto = require('crypto');
 var zlib = require('zlib');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var zlib__default = /*#__PURE__*/_interopDefault(zlib);
+
 // src/provider/github.ts
 
 // src/utils/version.ts
@@ -121,11 +126,11 @@ async function defaultDownloadAsar(url, headers, onDownloading) {
   });
 }
 function hashBuffer(data, length) {
-  const hash = crypto.createHash("SHA256").update(data).digest("binary");
+  const hash = crypto__default.default.createHash("SHA256").update(data).digest("binary");
   return Buffer.from(hash).subarray(0, length);
 }
 function aesDecrypt(encryptedText, key, iv) {
-  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = crypto__default.default.createDecipheriv("aes-256-cbc", key, iv);
   return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
 }
 function defaultVerifySignature(buffer, version, signature, cert) {
@@ -134,14 +139,14 @@ function defaultVerifySignature(buffer, version, signature, cert) {
     if (ver !== version) {
       return false;
     }
-    return crypto.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return crypto__default.default.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
   } catch {
     return false;
   }
 }
 async function defaultUnzipFile(buffer) {
   return new Promise((resolve, reject) => {
-    zlib.brotliDecompress(buffer, (err, buffer2) => {
+    zlib__default.default.brotliDecompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       } else {

package/dist/provider.d.cts

@@ -0,0 +1,76 @@
+import { I as IProvider, d as defaultIsLowerVersion, a as UpdateJSON, U as UpdateInfo, D as DownloadingInfo, c as URLHandler, O as OnDownloading } from './types-CItP6bL-.cjs';
+import { f as defaultVerifySignature, a as defaultUnzipFile } from './zip-DPF5IFkK.cjs';
+import { Arrayable } from '@subframe7536/type-utils';
+
+declare abstract class BaseProvider implements IProvider {
+    name: string;
+    isLowerVersion: typeof defaultIsLowerVersion;
+    verifySignaure: typeof defaultVerifySignature;
+    unzipFile: typeof defaultUnzipFile;
+    abstract downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    abstract downloadAsar(name: string, info: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+interface GitHubProviderOptions {
+    /**
+     * github user name
+     */
+    username: string;
+    /**
+     * github repo name
+     */
+    repo: string;
+    /**
+     * github branch name that fetch version
+     * @default 'HEAD'
+     */
+    branch?: string;
+    /**
+     * extra headers
+     */
+    extraHeaders?: Record<string, string>;
+    /**
+     * custom url handler
+     *
+     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L40 public CDN links}
+     * @example
+     * (url, isDownloadAsar) => {
+     *   if (isDownloadAsar) {
+     *     url.hostname = 'mirror.ghproxy.com'
+     *     url.pathname = 'https://github.com' + url.pathname
+     *     return url
+     *   }
+     * }
+     */
+    urlHandler?: URLHandler;
+}
+declare class GitHubProvider extends BaseProvider {
+    name: string;
+    private options;
+    /**
+     * Update Provider for Github repo
+     * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+     * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+     *
+     * you can setup `urlHandler` in {@link GitHubProviderOptions} or `Updater` to modify url before request
+     * @param options provider options
+     */
+    constructor(options: GitHubProviderOptions);
+    get urlHandler(): URLHandler | undefined;
+    set urlHandler(handler: URLHandler);
+    private parseURL;
+    downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    downloadAsar(name: string, info: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+declare function getHeader(response: Record<string, Arrayable<string>>, headerKey: any): any;
+/**
+ * download json and parse UpdateJson
+ */
+declare function defaultDownloadUpdateJSON(url: string, headers: Record<string, any>): Promise<UpdateJSON>;
+/**
+ * download asar buffer, get total size from `Content-Length` header
+ */
+declare function defaultDownloadAsar(url: string, headers: Record<string, any>, onDownloading?: OnDownloading): Promise<Buffer>;
+
+export { BaseProvider, DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, defaultDownloadAsar, defaultDownloadUpdateJSON, getHeader };

package/dist/provider.d.ts

@@ -0,0 +1,76 @@
+import { I as IProvider, d as defaultIsLowerVersion, a as UpdateJSON, U as UpdateInfo, D as DownloadingInfo, c as URLHandler, O as OnDownloading } from './types-CItP6bL-.js';
+import { f as defaultVerifySignature, a as defaultUnzipFile } from './zip-DPF5IFkK.js';
+import { Arrayable } from '@subframe7536/type-utils';
+
+declare abstract class BaseProvider implements IProvider {
+    name: string;
+    isLowerVersion: typeof defaultIsLowerVersion;
+    verifySignaure: typeof defaultVerifySignature;
+    unzipFile: typeof defaultUnzipFile;
+    abstract downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    abstract downloadAsar(name: string, info: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+interface GitHubProviderOptions {
+    /**
+     * github user name
+     */
+    username: string;
+    /**
+     * github repo name
+     */
+    repo: string;
+    /**
+     * github branch name that fetch version
+     * @default 'HEAD'
+     */
+    branch?: string;
+    /**
+     * extra headers
+     */
+    extraHeaders?: Record<string, string>;
+    /**
+     * custom url handler
+     *
+     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L40 public CDN links}
+     * @example
+     * (url, isDownloadAsar) => {
+     *   if (isDownloadAsar) {
+     *     url.hostname = 'mirror.ghproxy.com'
+     *     url.pathname = 'https://github.com' + url.pathname
+     *     return url
+     *   }
+     * }
+     */
+    urlHandler?: URLHandler;
+}
+declare class GitHubProvider extends BaseProvider {
+    name: string;
+    private options;
+    /**
+     * Update Provider for Github repo
+     * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+     * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+     *
+     * you can setup `urlHandler` in {@link GitHubProviderOptions} or `Updater` to modify url before request
+     * @param options provider options
+     */
+    constructor(options: GitHubProviderOptions);
+    get urlHandler(): URLHandler | undefined;
+    set urlHandler(handler: URLHandler);
+    private parseURL;
+    downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    downloadAsar(name: string, info: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+declare function getHeader(response: Record<string, Arrayable<string>>, headerKey: any): any;
+/**
+ * download json and parse UpdateJson
+ */
+declare function defaultDownloadUpdateJSON(url: string, headers: Record<string, any>): Promise<UpdateJSON>;
+/**
+ * download asar buffer, get total size from `Content-Length` header
+ */
+declare function defaultDownloadAsar(url: string, headers: Record<string, any>, onDownloading?: OnDownloading): Promise<Buffer>;
+
+export { BaseProvider, DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, defaultDownloadAsar, defaultDownloadUpdateJSON, getHeader };

package/dist/provider.js

@@ -1,4 +1,4 @@
-import { defaultVerifySignature, defaultUnzipFile } from './chunk-N77WQ5WB.js';
+import { defaultVerifySignature, defaultUnzipFile } from './chunk-KZSYEXLO.js';
 import { defaultIsLowerVersion, isUpdateJSON } from './chunk-72ZAJ7AF.js';
 import { URL } from 'node:url';
 import { app, net } from 'electron';

package/dist/types-CItP6bL-.d.cts

@@ -0,0 +1,104 @@
+import { Promisable } from '@subframe7536/type-utils';
+
+interface Version {
+    major: number;
+    minor: number;
+    patch: number;
+    stage: string;
+    stageVersion: number;
+}
+declare function parseVersion(version: string): Version;
+declare function defaultIsLowerVersion(oldVer: string, newVer: string): boolean;
+/**
+ * update info json
+ */
+type UpdateInfo = {
+    signature: string;
+    minimumVersion: string;
+    version: string;
+};
+/**
+ * {@link UpdateInfo} with beta
+ */
+type UpdateJSON = UpdateInfo & {
+    beta: UpdateInfo;
+};
+declare function isUpdateJSON(json: any): json is UpdateJSON;
+declare function defaultVersionJsonGenerator(existingJson: UpdateJSON, signature: string, version: string, minimumVersion: string): UpdateJSON;
+
+type URLHandler = (url: URL, isDownloadAsar: boolean) => Promisable<URL | string | undefined | null>;
+type OnDownloading = (progress: DownloadingInfo) => void;
+interface DownloadingInfo {
+    /**
+     * download delta
+     */
+    delta: number;
+    /**
+     * downloaded percent, 0 ~ 100
+     *
+     * If not `Content-Length` header, will be nagative
+     */
+    percent: number;
+    /**
+     * total size
+     *
+     * If not `Content-Length` header, will be -1
+     */
+    total: number;
+    /**
+     * downloaded size
+     */
+    transferred: number;
+    /**
+     * download speed, bytes per second
+     */
+    bps: number;
+}
+interface IProvider {
+    /**
+     * provider name
+     */
+    name: string;
+    /**
+     * custom url handler
+     *
+     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDN links}
+     */
+    urlHandler?: URLHandler;
+    onDownloading?: OnDownloading;
+    /**
+     * download update json
+     * @param versionPath parsed version path
+     */
+    downloadJSON: (versionPath: string) => Promise<UpdateJSON>;
+    /**
+     * download update asar
+     * @param name app name
+     * @param updateInfo existing update info
+     * @param onDownloading hook for on downloading
+     */
+    downloadAsar: (name: string, updateInfo: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void) => Promise<Buffer>;
+    /**
+     * compare version
+     * @param oldVer old version string
+     * @param newVer new version string
+     * @returns if version1 < version2
+     */
+    isLowerVersion: (oldVer: string, newVer: string) => boolean;
+    /**
+     * unzip file buffer
+     * @param buffer source buffer
+     */
+    unzipFile: (buffer: Buffer) => Promise<Buffer>;
+    /**
+     * verify asar signature
+     * @param buffer file buffer
+     * @param version target version
+     * @param signature signature
+     * @param cert certificate
+     * @returns if signature is valid, returns the version, otherwise returns `undefined`
+     */
+    verifySignaure: (buffer: Buffer, version: string, signature: string, cert: string) => Promisable<boolean>;
+}
+
+export { type DownloadingInfo as D, type IProvider as I, type OnDownloading as O, type UpdateInfo as U, type Version as V, type UpdateJSON as a, defaultVersionJsonGenerator as b, type URLHandler as c, defaultIsLowerVersion as d, isUpdateJSON as i, parseVersion as p };

package/dist/types-CItP6bL-.d.ts

@@ -0,0 +1,104 @@
+import { Promisable } from '@subframe7536/type-utils';
+
+interface Version {
+    major: number;
+    minor: number;
+    patch: number;
+    stage: string;
+    stageVersion: number;
+}
+declare function parseVersion(version: string): Version;
+declare function defaultIsLowerVersion(oldVer: string, newVer: string): boolean;
+/**
+ * update info json
+ */
+type UpdateInfo = {
+    signature: string;
+    minimumVersion: string;
+    version: string;
+};
+/**
+ * {@link UpdateInfo} with beta
+ */
+type UpdateJSON = UpdateInfo & {
+    beta: UpdateInfo;
+};
+declare function isUpdateJSON(json: any): json is UpdateJSON;
+declare function defaultVersionJsonGenerator(existingJson: UpdateJSON, signature: string, version: string, minimumVersion: string): UpdateJSON;
+
+type URLHandler = (url: URL, isDownloadAsar: boolean) => Promisable<URL | string | undefined | null>;
+type OnDownloading = (progress: DownloadingInfo) => void;
+interface DownloadingInfo {
+    /**
+     * download delta
+     */
+    delta: number;
+    /**
+     * downloaded percent, 0 ~ 100
+     *
+     * If not `Content-Length` header, will be nagative
+     */
+    percent: number;
+    /**
+     * total size
+     *
+     * If not `Content-Length` header, will be -1
+     */
+    total: number;
+    /**
+     * downloaded size
+     */
+    transferred: number;
+    /**
+     * download speed, bytes per second
+     */
+    bps: number;
+}
+interface IProvider {
+    /**
+     * provider name
+     */
+    name: string;
+    /**
+     * custom url handler
+     *
+     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDN links}
+     */
+    urlHandler?: URLHandler;
+    onDownloading?: OnDownloading;
+    /**
+     * download update json
+     * @param versionPath parsed version path
+     */
+    downloadJSON: (versionPath: string) => Promise<UpdateJSON>;
+    /**
+     * download update asar
+     * @param name app name
+     * @param updateInfo existing update info
+     * @param onDownloading hook for on downloading
+     */
+    downloadAsar: (name: string, updateInfo: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void) => Promise<Buffer>;
+    /**
+     * compare version
+     * @param oldVer old version string
+     * @param newVer new version string
+     * @returns if version1 < version2
+     */
+    isLowerVersion: (oldVer: string, newVer: string) => boolean;
+    /**
+     * unzip file buffer
+     * @param buffer source buffer
+     */
+    unzipFile: (buffer: Buffer) => Promise<Buffer>;
+    /**
+     * verify asar signature
+     * @param buffer file buffer
+     * @param version target version
+     * @param signature signature
+     * @param cert certificate
+     * @returns if signature is valid, returns the version, otherwise returns `undefined`
+     */
+    verifySignaure: (buffer: Buffer, version: string, signature: string, cert: string) => Promisable<boolean>;
+}
+
+export { type DownloadingInfo as D, type IProvider as I, type OnDownloading as O, type UpdateInfo as U, type Version as V, type UpdateJSON as a, defaultVersionJsonGenerator as b, type URLHandler as c, defaultIsLowerVersion as d, isUpdateJSON as i, parseVersion as p };

package/dist/utils.cjs

@@ -5,7 +5,13 @@ var path = require('path');
 var electron = require('electron');
 var zlib = require('zlib');
 var crypto = require('crypto');
-var ciInfo = require('ci-info');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var zlib__default = /*#__PURE__*/_interopDefault(zlib);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -17,17 +23,17 @@ var isDev = __EIU_IS_DEV__;
 var isWin = process.platform === "win32";
 var isMac = process.platform === "darwin";
 var isLinux = process.platform === "linux";
-function getPathFromAppNameAsar(...path$1) {
-  return isDev ? "DEV.asar" : path.join(path.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...path$1);
+function getPathFromAppNameAsar(...paths) {
+  return isDev ? "DEV.asar" : path__default.default.join(path__default.default.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...paths);
 }
 function getAppVersion() {
-  return isDev ? getEntryVersion() : fs.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+  return isDev ? getEntryVersion() : fs__default.default.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
 }
 function getEntryVersion() {
   return electron.app.getVersion();
 }
 function requireNative(moduleName) {
-  return __require(path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
+  return __require(path__default.default.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
 }
 function restartApp() {
   electron.app.relaunch();
@@ -61,9 +67,9 @@ function singleInstance(window) {
   return result;
 }
 function setPortableAppDataPath(dirName = "data") {
-  const portablePath = path.join(path.dirname(electron.app.getPath("exe")), dirName);
-  if (!fs.existsSync(portablePath)) {
-    fs.mkdirSync(portablePath);
+  const portablePath = path__default.default.join(path__default.default.dirname(electron.app.getPath("exe")), dirName);
+  if (!fs__default.default.existsSync(portablePath)) {
+    fs__default.default.mkdirSync(portablePath);
   }
   electron.app.setPath("appData", portablePath);
 }
@@ -75,13 +81,13 @@ function loadPage(win, htmlFilePath = "index.html") {
   }
 }
 function getPathFromPreload(...paths) {
-  return isDev ? path.join(electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+  return isDev ? path__default.default.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);
+  return isDev ? path__default.default.join(electron.app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
 }
 function getPathFromEntryAsar(...paths) {
-  return path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
+  return path__default.default.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
 }
 function handleUnexpectedErrors(callback) {
   process.on("uncaughtException", callback);
@@ -89,7 +95,7 @@ function handleUnexpectedErrors(callback) {
 }
 async function defaultZipFile(buffer) {
   return new Promise((resolve, reject) => {
-    zlib.brotliCompress(buffer, (err, buffer2) => {
+    zlib__default.default.brotliCompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       } else {
@@ -100,7 +106,7 @@ async function defaultZipFile(buffer) {
 }
 async function defaultUnzipFile(buffer) {
   return new Promise((resolve, reject) => {
-    zlib.brotliDecompress(buffer, (err, buffer2) => {
+    zlib__default.default.brotliDecompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       } else {
@@ -172,19 +178,19 @@ function defaultVersionJsonGenerator(existingJson, signature, version, minimumVe
   return existingJson;
 }
 function hashBuffer(data, length) {
-  const hash = crypto.createHash("SHA256").update(data).digest("binary");
+  const hash = crypto__default.default.createHash("SHA256").update(data).digest("binary");
   return Buffer.from(hash).subarray(0, length);
 }
 function aesEncrypt(plainText, key, iv) {
-  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+  const cipher = crypto__default.default.createCipheriv("aes-256-cbc", key, iv);
   return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
 }
 function defaultSignature(buffer, privateKey, cert, version) {
-  const sig = crypto.createSign("RSA-SHA256").update(buffer).sign(crypto.createPrivateKey(privateKey), "base64");
+  const sig = crypto__default.default.createSign("RSA-SHA256").update(buffer).sign(crypto__default.default.createPrivateKey(privateKey), "base64");
   return aesEncrypt(`${sig}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
 }
 function aesDecrypt(encryptedText, key, iv) {
-  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = crypto__default.default.createDecipheriv("aes-256-cbc", key, iv);
   return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
 }
 function defaultVerifySignature(buffer, version, signature, cert) {
@@ -193,7 +199,7 @@ function defaultVerifySignature(buffer, version, signature, cert) {
     if (ver !== version) {
       return false;
     }
-    return crypto.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return crypto__default.default.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
   } catch {
     return false;
   }
@@ -206,10 +212,6 @@ async function autoUpdate(updater) {
   }
 }
 
-Object.defineProperty(exports, "isCI", {
-  enumerable: true,
-  get: function () { return ciInfo.isCI; }
-});
 exports.aesDecrypt = aesDecrypt;
 exports.aesEncrypt = aesEncrypt;
 exports.autoUpdate = autoUpdate;

package/dist/utils.d.cts

@@ -0,0 +1,80 @@
+import { BrowserWindow } from 'electron';
+export { e as aesDecrypt, b as aesEncrypt, c as defaultSignature, a as defaultUnzipFile, f as defaultVerifySignature, d as defaultZipFile, h as hashBuffer } from './zip-DPF5IFkK.cjs';
+export { U as UpdateInfo, a as UpdateJSON, V as Version, d as defaultIsLowerVersion, b as defaultVersionJsonGenerator, i as isUpdateJSON, p as parseVersion } from './types-CItP6bL-.cjs';
+import { U as Updater } from './core-ZUlLHadf.cjs';
+import '@subframe7536/type-utils';
+import 'node:events';
+
+/**
+ * compile time dev check
+ */
+declare const isDev: boolean;
+declare const isWin: boolean;
+declare const isMac: boolean;
+declare const isLinux: boolean;
+/**
+ * get the absolute path of `${electron.app.name}.asar` (not `app.asar`)
+ *
+ * if is in dev, **always** return `'DEV.asar'`
+ */
+declare function getPathFromAppNameAsar(...paths: string[]): string;
+/**
+ * get app version, if is in dev, return `getEntryVersion()`
+ */
+declare function getAppVersion(): string;
+/**
+ * get entry version
+ */
+declare function getEntryVersion(): string;
+/**
+ * use `require` to load native module from entry
+ * @param moduleName file name in entry
+ */
+declare function requireNative<T = any>(moduleName: string): T;
+/**
+ * Restarts the Electron app.
+ */
+declare function restartApp(): void;
+/**
+ * fix app use model id, only for Windows
+ * @param id app id, default is `org.${electron.app.name}`
+ */
+declare function setAppUserModelId(id?: string): void;
+/**
+ * disable hardware acceleration for Windows 7
+ */
+declare function disableHWAccForWin7(): void;
+/**
+ * keep single electron instance and auto restore window on `second-instance` event
+ * @param window brwoser window to show
+ * @returns `false` if the app is running
+ */
+declare function singleInstance(window?: BrowserWindow): boolean;
+/**
+ * set `AppData` dir to the dir of .exe file
+ *
+ * useful for portable Windows app
+ * @param dirName dir name, default to `data`
+ */
+declare function setPortableAppDataPath(dirName?: string): void;
+/**
+ * load `process.env.VITE_DEV_SERVER_URL` when dev, else load html file
+ * @param win window
+ * @param htmlFilePath html file path, default is `index.html`
+ */
+declare function loadPage(win: BrowserWindow, htmlFilePath?: string): void;
+declare function getPathFromPreload(...paths: string[]): string;
+declare function getPathFromPublic(...paths: string[]): string;
+declare function getPathFromEntryAsar(...paths: string[]): string;
+/**
+ * handle all unhandled error
+ * @param callback callback function
+ */
+declare function handleUnexpectedErrors(callback: (err: unknown) => void): void;
+
+/**
+ * auto check update, download and install
+ */
+declare function autoUpdate(updater: Updater): Promise<void>;
+
+export { autoUpdate, disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, handleUnexpectedErrors, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };