electron-incremental-update 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/{types-COqp44eg.d.cts → types-Bz1VD18z.d.ts}

@@ -1,7 +1,38 @@
 import { Promisable } from '@subframe7536/type-utils';
-import { U as UpdateJSON, a as UpdateInfo } from './version-CffZWDhZ.cjs';
 
-type URLHandler = (url: string, isDownloadAsar: boolean) => string;
+/**
+ * handle all unhandled error
+ * @param callback callback function
+ */
+declare function handleUnexpectedErrors(callback: (err: unknown) => void): void;
+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;
+    size: number;
+};
+/**
+ * {@link UpdateInfo} with beta
+ */
+type UpdateJSON = UpdateInfo & {
+    beta: UpdateInfo;
+};
+declare function isUpdateJSON(json: any): json is UpdateJSON;
+declare function defaultVersionJsonGenerator(existingJson: UpdateJSON, buffer: Buffer, 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 {
     /**
@@ -56,6 +87,11 @@ interface IProvider {
      * @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
@@ -66,4 +102,4 @@ interface IProvider {
     verifySignaure: (buffer: Buffer, signature: string, cert: string) => Promisable<string | undefined>;
 }
 
-export type { DownloadingInfo as D, IProvider as I, OnDownloading as O, URLHandler as U };
+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, handleUnexpectedErrors as h, isUpdateJSON as i, parseVersion as p };

package/dist/utils.cjs

@@ -1,95 +1,51 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/utils/index.ts
-var utils_exports = {};
-__export(utils_exports, {
-  decrypt: () => decrypt,
-  disableHWAccForWin7: () => disableHWAccForWin7,
-  encrypt: () => encrypt,
-  getAppVersion: () => getAppVersion,
-  getEntryVersion: () => getEntryVersion,
-  getPathFromAppNameAsar: () => getPathFromAppNameAsar,
-  getPathFromEntryAsar: () => getPathFromEntryAsar,
-  getPathFromPreload: () => getPathFromPreload,
-  getPathFromPublic: () => getPathFromPublic,
-  handleUnexpectedErrors: () => handleUnexpectedErrors,
-  hashString: () => hashString,
-  isDev: () => isDev,
-  isLinux: () => isLinux,
-  isLowerVersionDefault: () => isLowerVersionDefault,
-  isMac: () => isMac,
-  isUpdateJSON: () => isUpdateJSON,
-  isWin: () => isWin,
-  loadPage: () => loadPage,
-  parseVersion: () => parseVersion,
-  requireNative: () => requireNative,
-  restartApp: () => restartApp,
-  setAppUserModelId: () => setAppUserModelId,
-  setPortableAppDataPath: () => setPortableAppDataPath,
-  signature: () => signature,
-  singleInstance: () => singleInstance,
-  unzipFile: () => unzipFile,
-  verifySignatureDefault: () => verifySignatureDefault,
-  waitAppReady: () => waitAppReady,
-  zipFile: () => zipFile
-});
-module.exports = __toCommonJS(utils_exports);
+var fs = require('fs');
+var path = require('path');
+var electron = require('electron');
+var zlib = require('zlib');
+var crypto = require('crypto');
 
-// src/utils/electron.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_electron = require("electron");
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var isDev = __EIU_IS_DEV__;
 var isWin = process.platform === "win32";
 var isMac = process.platform === "darwin";
 var isLinux = process.platform === "linux";
-function getPathFromAppNameAsar(...path) {
-  return isDev ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${import_electron.app.name}.asar`, ...path);
+function getPathFromAppNameAsar(...path$1) {
+  return isDev ? "DEV.asar" : path.join(path.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...path$1);
 }
 function getAppVersion() {
-  return isDev ? getEntryVersion() : (0, import_node_fs.readFileSync)(getPathFromAppNameAsar("version"), "utf-8");
+  return isDev ? getEntryVersion() : fs.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
 }
 function getEntryVersion() {
-  return import_electron.app.getVersion();
+  return electron.app.getVersion();
 }
 function requireNative(moduleName) {
-  return require((0, import_node_path.join)(import_electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
+  return __require(path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
 }
 function restartApp() {
-  import_electron.app.relaunch();
-  import_electron.app.quit();
+  electron.app.relaunch();
+  electron.app.quit();
 }
 function setAppUserModelId(id) {
   if (isWin) {
-    import_electron.app.setAppUserModelId(id ?? `org.${import_electron.app.name}`);
+    electron.app.setAppUserModelId(id ?? `org.${electron.app.name}`);
   }
 }
 function disableHWAccForWin7() {
-  if (require("os").release().startsWith("6.1")) {
-    import_electron.app.disableHardwareAcceleration();
+  if (__require("os").release().startsWith("6.1")) {
+    electron.app.disableHardwareAcceleration();
   }
 }
 function singleInstance(window) {
-  const result = import_electron.app.requestSingleInstanceLock();
+  const result = electron.app.requestSingleInstanceLock();
   if (result) {
-    import_electron.app.on("second-instance", () => {
+    electron.app.on("second-instance", () => {
       if (window) {
         window.show();
         if (window.isMinimized()) {
@@ -99,27 +55,16 @@ function singleInstance(window) {
       }
     });
   } else {
-    import_electron.app.quit();
+    electron.app.quit();
   }
   return result;
 }
 function setPortableAppDataPath(dirName = "data") {
-  const portablePath = (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getPath("exe")), dirName);
-  if (!(0, import_node_fs.existsSync)(portablePath)) {
-    (0, import_node_fs.mkdirSync)(portablePath);
+  const portablePath = path.join(path.dirname(electron.app.getPath("exe")), dirName);
+  if (!fs.existsSync(portablePath)) {
+    fs.mkdirSync(portablePath);
   }
-  import_electron.app.setPath("appData", portablePath);
-}
-function waitAppReady(timeout = 1e3) {
-  return import_electron.app.isReady() ? Promise.resolve() : new Promise((resolve, reject) => {
-    const _ = setTimeout(() => {
-      reject(new Error("app is not ready"));
-    }, timeout);
-    import_electron.app.whenReady().then(() => {
-      clearTimeout(_);
-      resolve();
-    });
-  });
+  electron.app.setPath("appData", portablePath);
 }
 function loadPage(win, htmlFilePath = "index.html") {
   if (isDev) {
@@ -129,50 +74,33 @@ function loadPage(win, htmlFilePath = "index.html") {
   }
 }
 function getPathFromPreload(...paths) {
-  return isDev ? (0, import_node_path.join)(import_electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+  return isDev ? path.join(electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
 }
 function getPathFromPublic(...paths) {
-  return isDev ? (0, import_node_path.join)(import_electron.app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+  return isDev ? path.join(electron.app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
 }
 function getPathFromEntryAsar(...paths) {
-  return (0, import_node_path.join)(import_electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
+  return path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
 }
-
-// src/utils/zip.ts
-var import_node_fs2 = require("fs");
-var import_node_zlib = require("zlib");
-async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
-  if (!(0, import_node_fs2.existsSync)(filePath)) {
-    throw new Error(`path to be zipped not exist: ${filePath}`);
-  }
-  const buffer = (0, import_node_fs2.readFileSync)(filePath);
+async function defaultZipFile(buffer) {
   return new Promise((resolve, reject) => {
-    (0, import_node_zlib.brotliCompress)(buffer, (err, buffer2) => {
+    zlib.brotliCompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
+      } else {
+        resolve(buffer2);
       }
-      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer2);
-      resolve();
     });
   });
 }
-
-// src/utils/unzip.ts
-var import_node_fs3 = require("fs");
-var import_node_zlib2 = require("zlib");
-async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
-  if (!(0, import_node_fs3.existsSync)(gzipPath)) {
-    throw new Error(`path to zipped file not exist: ${gzipPath}`);
-  }
-  const compressedBuffer = (0, import_node_fs3.readFileSync)(gzipPath);
+async function defaultUnzipFile(buffer) {
   return new Promise((resolve, reject) => {
-    (0, import_node_zlib2.brotliDecompress)(compressedBuffer, (err, buffer) => {
-      (0, import_node_fs3.rmSync)(gzipPath);
+    zlib.brotliDecompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
+      } else {
+        resolve(buffer2);
       }
-      (0, import_node_fs3.writeFileSync)(targetFilePath, buffer);
-      resolve();
     });
   });
 }
@@ -205,7 +133,7 @@ function parseVersion(version) {
   }
   return ret;
 }
-function isLowerVersionDefault(oldVer, newVer) {
+function defaultIsLowerVersion(oldVer, newVer) {
   const oldV = parseVersion(oldVer);
   const newV = parseVersion(newVer);
   function compareStrings(str1, str2) {
@@ -229,75 +157,81 @@ function isUpdateJSON(json) {
   const is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
   return is(json) && is(json?.beta);
 }
-
-// src/utils/crypto/decrypt.ts
-var import_node_crypto2 = require("crypto");
-
-// src/utils/crypto/utils.ts
-var import_node_crypto = require("crypto");
-function hashString(data, length) {
-  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
+function defaultVersionJsonGenerator(existingJson, buffer, signature, version, minimumVersion) {
+  existingJson.beta = {
+    version,
+    minimumVersion,
+    signature,
+    size: buffer.length
+  };
+  if (!parseVersion(version).stage) {
+    existingJson.version = version;
+    existingJson.minimumVersion = minimumVersion;
+    existingJson.signature = signature;
+    existingJson.size = buffer.length;
+  }
+  return existingJson;
+}
+function hashBuffer(data, length) {
+  const hash = crypto.createHash("SHA256").update(data).digest("binary");
   return Buffer.from(hash).subarray(0, length);
 }
-
-// src/utils/crypto/decrypt.ts
-function decrypt(encryptedText, key, iv) {
-  const decipher = (0, import_node_crypto2.createDecipheriv)("aes-256-cbc", key, iv);
-  let decrypted = decipher.update(encryptedText, "base64url", "utf8");
-  decrypted += decipher.final("utf8");
-  return decrypted;
+function aesEncrypt(plainText, key, iv) {
+  const cipher = crypto.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");
+  return aesEncrypt(`${sig}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
 }
-function verifySignatureDefault(buffer, signature2, cert) {
+function aesDecrypt(encryptedText, key, iv) {
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
+}
+function defaultVerify(buffer, signature, cert) {
   try {
-    const [sig, version] = decrypt(signature2, hashString(cert, 32), hashString(buffer, 16)).split("%");
-    const result = (0, import_node_crypto2.createVerify)("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    const [sig, version] = aesDecrypt(signature, hashBuffer(cert, 32), hashBuffer(buffer, 16)).split("%");
+    const result = crypto.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
     return result ? version : void 0;
   } catch {
     return void 0;
   }
 }
 
-// src/utils/crypto/encrypt.ts
-var import_node_crypto3 = require("crypto");
-function encrypt(plainText, key, iv) {
-  const cipher = (0, import_node_crypto3.createCipheriv)("aes-256-cbc", key, iv);
-  let encrypted = cipher.update(plainText, "utf8", "base64url");
-  encrypted += cipher.final("base64url");
-  return encrypted;
-}
-function signature(buffer, privateKey, cert, version) {
-  const sig = (0, import_node_crypto3.createSign)("RSA-SHA256").update(buffer).sign((0, import_node_crypto3.createPrivateKey)(privateKey), "base64");
-  return encrypt(`${sig}%${version}`, hashString(cert, 32), hashString(buffer, 16));
+// src/utils/updater.ts
+async function autoUpdate(updater) {
+  if (await updater.checkUpdate() && await updater.downloadUpdate()) {
+    updater.quitAndInstall();
+  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  decrypt,
-  disableHWAccForWin7,
-  encrypt,
-  getAppVersion,
-  getEntryVersion,
-  getPathFromAppNameAsar,
-  getPathFromEntryAsar,
-  getPathFromPreload,
-  getPathFromPublic,
-  handleUnexpectedErrors,
-  hashString,
-  isDev,
-  isLinux,
-  isLowerVersionDefault,
-  isMac,
-  isUpdateJSON,
-  isWin,
-  loadPage,
-  parseVersion,
-  requireNative,
-  restartApp,
-  setAppUserModelId,
-  setPortableAppDataPath,
-  signature,
-  singleInstance,
-  unzipFile,
-  verifySignatureDefault,
-  waitAppReady,
-  zipFile
-});
+
+exports.aesDecrypt = aesDecrypt;
+exports.aesEncrypt = aesEncrypt;
+exports.autoUpdate = autoUpdate;
+exports.defaultIsLowerVersion = defaultIsLowerVersion;
+exports.defaultSignature = defaultSignature;
+exports.defaultUnzipFile = defaultUnzipFile;
+exports.defaultVerify = defaultVerify;
+exports.defaultVersionJsonGenerator = defaultVersionJsonGenerator;
+exports.defaultZipFile = defaultZipFile;
+exports.disableHWAccForWin7 = disableHWAccForWin7;
+exports.getAppVersion = getAppVersion;
+exports.getEntryVersion = getEntryVersion;
+exports.getPathFromAppNameAsar = getPathFromAppNameAsar;
+exports.getPathFromEntryAsar = getPathFromEntryAsar;
+exports.getPathFromPreload = getPathFromPreload;
+exports.getPathFromPublic = getPathFromPublic;
+exports.handleUnexpectedErrors = handleUnexpectedErrors;
+exports.hashBuffer = hashBuffer;
+exports.isDev = isDev;
+exports.isLinux = isLinux;
+exports.isMac = isMac;
+exports.isUpdateJSON = isUpdateJSON;
+exports.isWin = isWin;
+exports.loadPage = loadPage;
+exports.parseVersion = parseVersion;
+exports.requireNative = requireNative;
+exports.restartApp = restartApp;
+exports.setAppUserModelId = setAppUserModelId;
+exports.setPortableAppDataPath = setPortableAppDataPath;
+exports.singleInstance = singleInstance;

package/dist/utils.d.cts

@@ -1,6 +1,9 @@
 import { BrowserWindow } from 'electron';
-export { a as UpdateInfo, U as UpdateJSON, V as Version, h as handleUnexpectedErrors, i as isLowerVersionDefault, b as isUpdateJSON, p as parseVersion } from './version-CffZWDhZ.cjs';
-export { d as decrypt, v as verifySignatureDefault } from './decrypt-D9WdXYjH.cjs';
+export { e as aesDecrypt, b as aesEncrypt, c as defaultSignature, a as defaultUnzipFile, f as defaultVerify, d as defaultZipFile, h as hashBuffer } from './zip-WRrEMkgp.cjs';
+export { U as UpdateInfo, a as UpdateJSON, V as Version, d as defaultIsLowerVersion, b as defaultVersionJsonGenerator, h as handleUnexpectedErrors, i as isUpdateJSON, p as parseVersion } from './types-Bz1VD18z.cjs';
+import { U as Updater } from './core-CW7TMqi7.cjs';
+import '@subframe7536/type-utils';
+import 'node:events';
 
 /**
  * compile time dev check
@@ -54,11 +57,6 @@ declare function singleInstance(window?: BrowserWindow): boolean;
  * @param dirName dir name, default to `data`
  */
 declare function setPortableAppDataPath(dirName?: string): void;
-/**
- * ensure app is ready.
- * @param timeout wait timeout, @default 1000
- */
-declare function waitAppReady(timeout?: number): Promise<void>;
 /**
  * load `process.env.VITE_DEV_SERVER_URL` when dev, else load html file
  * @param win window
@@ -69,13 +67,9 @@ declare function getPathFromPreload(...paths: string[]): string;
 declare function getPathFromPublic(...paths: string[]): string;
 declare function getPathFromEntryAsar(...paths: string[]): string;
 
-declare function zipFile(filePath: string, targetFilePath?: string): Promise<void>;
-
-declare function unzipFile(gzipPath: string, targetFilePath?: string): Promise<void>;
-
-declare function encrypt(plainText: string, key: Buffer, iv: Buffer): string;
-declare function signature(buffer: Buffer, privateKey: string, cert: string, version: string): string;
-
-declare function hashString(data: string | Buffer, length: number): Buffer;
+/**
+ * auto check update, download and install
+ */
+declare function autoUpdate(updater: Updater): Promise<void>;
 
-export { disableHWAccForWin7, encrypt, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, hashString, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, signature, singleInstance, unzipFile, waitAppReady, zipFile };
+export { autoUpdate, disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };

package/dist/utils.d.ts

@@ -1,6 +1,9 @@
 import { BrowserWindow } from 'electron';
-export { a as UpdateInfo, U as UpdateJSON, V as Version, h as handleUnexpectedErrors, i as isLowerVersionDefault, b as isUpdateJSON, p as parseVersion } from './version-CffZWDhZ.js';
-export { d as decrypt, v as verifySignatureDefault } from './decrypt-D9WdXYjH.js';
+export { e as aesDecrypt, b as aesEncrypt, c as defaultSignature, a as defaultUnzipFile, f as defaultVerify, d as defaultZipFile, h as hashBuffer } from './zip-WRrEMkgp.js';
+export { U as UpdateInfo, a as UpdateJSON, V as Version, d as defaultIsLowerVersion, b as defaultVersionJsonGenerator, h as handleUnexpectedErrors, i as isUpdateJSON, p as parseVersion } from './types-Bz1VD18z.js';
+import { U as Updater } from './core-D6QlpOgp.js';
+import '@subframe7536/type-utils';
+import 'node:events';
 
 /**
  * compile time dev check
@@ -54,11 +57,6 @@ declare function singleInstance(window?: BrowserWindow): boolean;
  * @param dirName dir name, default to `data`
  */
 declare function setPortableAppDataPath(dirName?: string): void;
-/**
- * ensure app is ready.
- * @param timeout wait timeout, @default 1000
- */
-declare function waitAppReady(timeout?: number): Promise<void>;
 /**
  * load `process.env.VITE_DEV_SERVER_URL` when dev, else load html file
  * @param win window
@@ -69,13 +67,9 @@ declare function getPathFromPreload(...paths: string[]): string;
 declare function getPathFromPublic(...paths: string[]): string;
 declare function getPathFromEntryAsar(...paths: string[]): string;
 
-declare function zipFile(filePath: string, targetFilePath?: string): Promise<void>;
-
-declare function unzipFile(gzipPath: string, targetFilePath?: string): Promise<void>;
-
-declare function encrypt(plainText: string, key: Buffer, iv: Buffer): string;
-declare function signature(buffer: Buffer, privateKey: string, cert: string, version: string): string;
-
-declare function hashString(data: string | Buffer, length: number): Buffer;
+/**
+ * auto check update, download and install
+ */
+declare function autoUpdate(updater: Updater): Promise<void>;
 
-export { disableHWAccForWin7, encrypt, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, hashString, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, signature, singleInstance, unzipFile, waitAppReady, zipFile };
+export { autoUpdate, disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };

package/dist/utils.js

@@ -1,62 +1,12 @@
-import {
-  decrypt,
-  disableHWAccForWin7,
-  encrypt,
-  getAppVersion,
-  getEntryVersion,
-  getPathFromAppNameAsar,
-  getPathFromEntryAsar,
-  getPathFromPreload,
-  getPathFromPublic,
-  handleUnexpectedErrors,
-  hashString,
-  isDev,
-  isLinux,
-  isLowerVersionDefault,
-  isMac,
-  isUpdateJSON,
-  isWin,
-  loadPage,
-  parseVersion,
-  requireNative,
-  restartApp,
-  setAppUserModelId,
-  setPortableAppDataPath,
-  signature,
-  singleInstance,
-  unzipFile,
-  verifySignatureDefault,
-  waitAppReady,
-  zipFile
-} from "./chunk-BG22XZAB.js";
-export {
-  decrypt,
-  disableHWAccForWin7,
-  encrypt,
-  getAppVersion,
-  getEntryVersion,
-  getPathFromAppNameAsar,
-  getPathFromEntryAsar,
-  getPathFromPreload,
-  getPathFromPublic,
-  handleUnexpectedErrors,
-  hashString,
-  isDev,
-  isLinux,
-  isLowerVersionDefault,
-  isMac,
-  isUpdateJSON,
-  isWin,
-  loadPage,
-  parseVersion,
-  requireNative,
-  restartApp,
-  setAppUserModelId,
-  setPortableAppDataPath,
-  signature,
-  singleInstance,
-  unzipFile,
-  verifySignatureDefault,
-  waitAppReady,
-  zipFile
-};
+export { disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance } from './chunk-PNYRQYFC.js';
+export { aesDecrypt, aesEncrypt, defaultSignature, defaultUnzipFile, defaultVerify, defaultZipFile, hashBuffer } from './chunk-JSYIRKTR.js';
+export { defaultIsLowerVersion, defaultVersionJsonGenerator, handleUnexpectedErrors, isUpdateJSON, parseVersion } from './chunk-BVFQWBLK.js';
+
+// src/utils/updater.ts
+async function autoUpdate(updater) {
+  if (await updater.checkUpdate() && await updater.downloadUpdate()) {
+    updater.quitAndInstall();
+  }
+}
+
+export { autoUpdate };