electron-incremental-update 0.7.6 → 0.7.8

package/dist/index.js

@@ -20,20 +20,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  MinimumVersionError: () => MinimumVersionError,
+  VerifyFailedError: () => VerifyFailedError,
   createUpdater: () => createUpdater,
   initApp: () => initApp
 });
 module.exports = __toCommonJS(src_exports);
 var import_node_path2 = require("path");
 var import_node_fs3 = require("fs");
-var import_electron4 = require("electron");
+var import_electron3 = require("electron");
 
 // src/updater/index.ts
 var import_node_events = require("events");
 var import_node_buffer3 = require("buffer");
 var import_node_fs2 = require("fs");
 var import_promises = require("fs/promises");
-var import_electron3 = require("electron");
 
 // src/crypto.ts
 var import_node_crypto = require("crypto");
@@ -69,6 +70,9 @@ function getProductAsarPath(name) {
 function getEntryVersion() {
   return import_electron.app.getVersion();
 }
+function getProductVersion(name) {
+  return import_electron.app.isPackaged ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(getProductAsarPath(name), "version"), "utf-8") : getEntryVersion();
+}
 function waitAppReady(duration = 1e3) {
   return new Promise((resolve2, reject) => {
     const timeout = setTimeout(() => {
@@ -96,17 +100,28 @@ async function unzipFile(gzipPath, targetFilePath) {
     });
   });
 }
+function parseVersion(version) {
+  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
+  const match = semver.exec(version);
+  if (!match) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  const [major, minor, patch] = match.slice(1, 4).map(Number);
+  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return { major, minor, patch, stage: match[4] };
+}
 
-// src/updater/defaultFunctions.ts
-var import_node_buffer2 = require("buffer");
-var import_electron2 = require("electron");
-
-// src/updater/types.ts
+// src/updateJson.ts
 function isUpdateJSON(json) {
-  return "signature" in json && "version" in json && "size" in json;
+  const is = (j) => "signature" in j && "version" in j && "size" in j && "minimumVersion" in j;
+  return is(json) && "beta" in json && is(json.beta);
 }
 
 // src/updater/defaultFunctions.ts
+var import_node_buffer2 = require("buffer");
+var import_electron2 = require("electron");
 async function downloadJSONDefault(url, updater, headers) {
   await waitAppReady();
   return new Promise((resolve2, reject) => {
@@ -169,20 +184,6 @@ async function downloadBufferDefault(url, updater, headers) {
   });
 }
 var compareVersionDefault = (oldVersion, newVersion) => {
-  if (!oldVersion || !newVersion || typeof oldVersion !== "string" || typeof newVersion !== "string") {
-    throw new TypeError("invalid version");
-  }
-  const parseVersion = (version) => {
-    const [versionNumber, stage] = version.split("-", 2);
-    if (!versionNumber || !versionNumber.includes(".")) {
-      throw new TypeError("invalid version");
-    }
-    const [major, minor, patch] = versionNumber.split(".").map(Number);
-    if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
-      throw new TypeError("invalid version");
-    }
-    return { major, minor, patch, stage };
-  };
   const oldV = parseVersion(oldVersion);
   const newV = parseVersion(newVersion);
   if (oldV.major < newV.major || oldV.major === newV.major && oldV.minor < newV.minor || oldV.major === newV.major && oldV.minor === newV.minor && oldV.patch < newV.patch) {
@@ -195,6 +196,24 @@ var compareVersionDefault = (oldVersion, newVersion) => {
 };
 
 // src/updater/index.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;
+  }
+};
 function createUpdater(updaterOptions) {
   const {
     SIGNATURE_CERT,
@@ -203,6 +222,7 @@ function createUpdater(updaterOptions) {
     releaseAsarURL: _release,
     updateJsonURL: _update,
     debug = false,
+    receiveBeta = false,
     downloadConfig: { extraHeader, userAgent } = {},
     overrideFunctions: {
       compareVersion,
@@ -214,22 +234,21 @@ function createUpdater(updaterOptions) {
   const updater = new import_node_events.EventEmitter();
   let signature;
   let version;
-  let _debug = debug;
   const asarPath = getProductAsarPath(productName);
   const gzipPath = `${asarPath}.gz`;
   const tmpFilePath = `${asarPath}.tmp`;
   function log(msg) {
-    _debug && updater.emit("debug", msg);
+    debug && updater.emit("debug", msg);
   }
-  function needUpdate(version2) {
-    if (!import_electron3.app.isPackaged) {
-      log("in dev mode, no need to update");
-      return false;
+  async function needUpdate(version2, minVersion) {
+    const compare = compareVersion ?? compareVersionDefault;
+    const productVersion = getProductVersion(productName);
+    const entryVersion = getEntryVersion();
+    if (await compare(entryVersion, minVersion)) {
+      throw new MinimumVersionError(entryVersion, minVersion);
     }
-    const currentVersion = getEntryVersion();
-    log(`check update: current version is ${currentVersion}, new version is ${version2}`);
-    const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version2);
+    log(`check update: current version is ${productVersion}, new version is ${version2}`);
+    return await compare(productVersion, version2);
   }
   async function parseData(format, data, version2) {
     if ((0, import_node_fs2.existsSync)(tmpFilePath)) {
@@ -244,7 +263,7 @@ function createUpdater(updaterOptions) {
       if (format === "json" && isUpdateJSON(data) || format === "buffer" && import_node_buffer3.Buffer.isBuffer(data)) {
         return data;
       } else {
-        throw new Error(`invalid type at format '${format}': ${data}`);
+        throw new TypeError(`invalid type at format '${format}': ${data}`);
       }
     } else if (["string", "undefined"].includes(typeof data)) {
       const ua = userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
@@ -279,18 +298,34 @@ function createUpdater(updaterOptions) {
       log(`download ${format} from ${data}`);
       const ret = await info.fn(data, updater, headers);
       log(`download ${format} success${format === "buffer" ? `, file size: ${ret.length}` : ""}`);
+      if (format === "buffer") {
+        updater.emit("downloadBuffer", ret);
+      }
       return ret;
     } else {
-      throw new Error(`invalid type at format '${format}': ${data}`);
+      throw new TypeError(`invalid type at format '${format}': ${data}`);
     }
   }
   updater.productName = productName;
-  updater.setDebugMode = (isDebug) => _debug = isDebug;
+  updater.debug = debug;
+  updater.receiveBeta = receiveBeta;
   updater.checkUpdate = async (data) => {
     try {
-      const { signature: _sig, size, version: _ver } = await parseData("json", data);
+      let {
+        signature: _sig,
+        size,
+        version: _ver,
+        minimumVersion,
+        beta
+      } = await parseData("json", data);
+      if (receiveBeta) {
+        _ver = beta.version;
+        _sig = beta.signature;
+        minimumVersion = beta.minimumVersion;
+        size = beta.size;
+      }
       log(`checked version: ${_ver}, size: ${size}, signature: ${_sig}`);
-      if (!needUpdate(_ver)) {
+      if (!await needUpdate(_ver, minimumVersion)) {
         log(`update unavailable: ${_ver}`);
         return void 0;
       } else {
@@ -313,9 +348,9 @@ function createUpdater(updaterOptions) {
       const buffer = await parseData("buffer", data, version);
       log("verify start");
       const _verify = verifySignaure ?? verify;
-      const _ver = _verify(buffer, _sig, SIGNATURE_CERT);
+      const _ver = await _verify(buffer, _sig, SIGNATURE_CERT);
       if (!_ver) {
-        throw new Error("verify failed, invalid signature");
+        throw new VerifyFailedError(_sig, SIGNATURE_CERT);
       }
       log("verify success");
       log(`write to ${gzipPath}`);
@@ -343,7 +378,7 @@ function initApp(appOptions) {
   } = appOptions || {};
   function handleError(msg) {
     onStartError?.(new Error(msg));
-    import_electron4.app.quit();
+    import_electron3.app.quit();
   }
   function startup(updater) {
     try {
@@ -351,7 +386,7 @@ function initApp(appOptions) {
       if ((0, import_node_fs3.existsSync)(`${asarPath}.tmp`)) {
         (0, import_node_fs3.renameSync)(`${asarPath}.tmp`, asarPath);
       }
-      const mainDir = import_electron4.app.isPackaged ? asarPath : electronDevDistPath;
+      const mainDir = import_electron3.app.isPackaged ? asarPath : electronDevDistPath;
       const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
       onStart?.(entry);
       require(entry)(updater);
@@ -377,6 +412,8 @@ function initApp(appOptions) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MinimumVersionError,
+  VerifyFailedError,
   createUpdater,
   initApp
 });

package/dist/index.mjs

@@ -1,36 +1,31 @@
 import {
+  isUpdateJSON,
   verify
-} from "./chunk-Q2K52LOG.mjs";
+} from "./chunk-2XHZMWRR.mjs";
 import {
   __require,
   getEntryVersion,
   getProductAsarPath,
+  getProductVersion,
+  parseVersion,
   unzipFile,
   waitAppReady
-} from "./chunk-67MCNA7W.mjs";
+} from "./chunk-SWXNCK6H.mjs";
 
 // src/index.ts
 import { resolve } from "node:path";
 import { existsSync as existsSync2, renameSync } from "node:fs";
-import { app as app2 } from "electron";
+import { app } from "electron";
 
 // src/updater/index.ts
 import { EventEmitter } from "node:events";
 import { Buffer as Buffer2 } from "node:buffer";
 import { existsSync } from "node:fs";
 import { rm, writeFile } from "node:fs/promises";
-import { app } from "electron";
 
 // src/updater/defaultFunctions.ts
 import { Buffer } from "node:buffer";
 import { net } from "electron";
-
-// src/updater/types.ts
-function isUpdateJSON(json) {
-  return "signature" in json && "version" in json && "size" in json;
-}
-
-// src/updater/defaultFunctions.ts
 async function downloadJSONDefault(url, updater, headers) {
   await waitAppReady();
   return new Promise((resolve2, reject) => {
@@ -93,20 +88,6 @@ async function downloadBufferDefault(url, updater, headers) {
   });
 }
 var compareVersionDefault = (oldVersion, newVersion) => {
-  if (!oldVersion || !newVersion || typeof oldVersion !== "string" || typeof newVersion !== "string") {
-    throw new TypeError("invalid version");
-  }
-  const parseVersion = (version) => {
-    const [versionNumber, stage] = version.split("-", 2);
-    if (!versionNumber || !versionNumber.includes(".")) {
-      throw new TypeError("invalid version");
-    }
-    const [major, minor, patch] = versionNumber.split(".").map(Number);
-    if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
-      throw new TypeError("invalid version");
-    }
-    return { major, minor, patch, stage };
-  };
   const oldV = parseVersion(oldVersion);
   const newV = parseVersion(newVersion);
   if (oldV.major < newV.major || oldV.major === newV.major && oldV.minor < newV.minor || oldV.major === newV.major && oldV.minor === newV.minor && oldV.patch < newV.patch) {
@@ -119,6 +100,24 @@ var compareVersionDefault = (oldVersion, newVersion) => {
 };
 
 // src/updater/index.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;
+  }
+};
 function createUpdater(updaterOptions) {
   const {
     SIGNATURE_CERT,
@@ -127,6 +126,7 @@ function createUpdater(updaterOptions) {
     releaseAsarURL: _release,
     updateJsonURL: _update,
     debug = false,
+    receiveBeta = false,
     downloadConfig: { extraHeader, userAgent } = {},
     overrideFunctions: {
       compareVersion,
@@ -138,22 +138,21 @@ function createUpdater(updaterOptions) {
   const updater = new EventEmitter();
   let signature;
   let version;
-  let _debug = debug;
   const asarPath = getProductAsarPath(productName);
   const gzipPath = `${asarPath}.gz`;
   const tmpFilePath = `${asarPath}.tmp`;
   function log(msg) {
-    _debug && updater.emit("debug", msg);
+    debug && updater.emit("debug", msg);
   }
-  function needUpdate(version2) {
-    if (!app.isPackaged) {
-      log("in dev mode, no need to update");
-      return false;
+  async function needUpdate(version2, minVersion) {
+    const compare = compareVersion ?? compareVersionDefault;
+    const productVersion = getProductVersion(productName);
+    const entryVersion = getEntryVersion();
+    if (await compare(entryVersion, minVersion)) {
+      throw new MinimumVersionError(entryVersion, minVersion);
     }
-    const currentVersion = getEntryVersion();
-    log(`check update: current version is ${currentVersion}, new version is ${version2}`);
-    const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version2);
+    log(`check update: current version is ${productVersion}, new version is ${version2}`);
+    return await compare(productVersion, version2);
   }
   async function parseData(format, data, version2) {
     if (existsSync(tmpFilePath)) {
@@ -168,7 +167,7 @@ function createUpdater(updaterOptions) {
       if (format === "json" && isUpdateJSON(data) || format === "buffer" && Buffer2.isBuffer(data)) {
         return data;
       } else {
-        throw new Error(`invalid type at format '${format}': ${data}`);
+        throw new TypeError(`invalid type at format '${format}': ${data}`);
       }
     } else if (["string", "undefined"].includes(typeof data)) {
       const ua = userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
@@ -203,18 +202,34 @@ function createUpdater(updaterOptions) {
       log(`download ${format} from ${data}`);
       const ret = await info.fn(data, updater, headers);
       log(`download ${format} success${format === "buffer" ? `, file size: ${ret.length}` : ""}`);
+      if (format === "buffer") {
+        updater.emit("downloadBuffer", ret);
+      }
       return ret;
     } else {
-      throw new Error(`invalid type at format '${format}': ${data}`);
+      throw new TypeError(`invalid type at format '${format}': ${data}`);
     }
   }
   updater.productName = productName;
-  updater.setDebugMode = (isDebug) => _debug = isDebug;
+  updater.debug = debug;
+  updater.receiveBeta = receiveBeta;
   updater.checkUpdate = async (data) => {
     try {
-      const { signature: _sig, size, version: _ver } = await parseData("json", data);
+      let {
+        signature: _sig,
+        size,
+        version: _ver,
+        minimumVersion,
+        beta
+      } = await parseData("json", data);
+      if (receiveBeta) {
+        _ver = beta.version;
+        _sig = beta.signature;
+        minimumVersion = beta.minimumVersion;
+        size = beta.size;
+      }
       log(`checked version: ${_ver}, size: ${size}, signature: ${_sig}`);
-      if (!needUpdate(_ver)) {
+      if (!await needUpdate(_ver, minimumVersion)) {
         log(`update unavailable: ${_ver}`);
         return void 0;
       } else {
@@ -237,9 +252,9 @@ function createUpdater(updaterOptions) {
       const buffer = await parseData("buffer", data, version);
       log("verify start");
       const _verify = verifySignaure ?? verify;
-      const _ver = _verify(buffer, _sig, SIGNATURE_CERT);
+      const _ver = await _verify(buffer, _sig, SIGNATURE_CERT);
       if (!_ver) {
-        throw new Error("verify failed, invalid signature");
+        throw new VerifyFailedError(_sig, SIGNATURE_CERT);
       }
       log("verify success");
       log(`write to ${gzipPath}`);
@@ -267,7 +282,7 @@ function initApp(appOptions) {
   } = appOptions || {};
   function handleError(msg) {
     onStartError?.(new Error(msg));
-    app2.quit();
+    app.quit();
   }
   function startup(updater) {
     try {
@@ -275,7 +290,7 @@ function initApp(appOptions) {
       if (existsSync2(`${asarPath}.tmp`)) {
         renameSync(`${asarPath}.tmp`, asarPath);
       }
-      const mainDir = app2.isPackaged ? asarPath : electronDevDistPath;
+      const mainDir = app.isPackaged ? asarPath : electronDevDistPath;
       const entry = resolve(__dirname, mainDir, mainPath);
       onStart?.(entry);
       __require(entry)(updater);
@@ -300,6 +315,8 @@ function initApp(appOptions) {
   };
 }
 export {
+  MinimumVersionError,
+  VerifyFailedError,
   createUpdater,
   initApp
 };

package/dist/updateJson-7e45d9e1.d.ts

@@ -0,0 +1,11 @@
+type UpdateInfo = {
+    signature: string;
+    minimumVersion: string;
+    version: string;
+    size: number;
+};
+type UpdateJSON = UpdateInfo & {
+    beta: UpdateInfo;
+};
+
+export { UpdateJSON as U };

package/dist/utils.d.mts

@@ -12,9 +12,14 @@ declare function getEntryVersion(): string;
  * @param name - The name of the application
  */
 declare function getProductVersion(name: string): string;
+declare class NoSuchNativeModuleError extends Error {
+    moduleName: string;
+    constructor(moduleName: string);
+}
 /**
  * require native package from app.asar
  * @param packageName native package name
+ * @throws error: {@link NoSuchNativeModuleError}
  */
 declare function requireNative<T = any>(packageName: string): T;
 /**
@@ -40,5 +45,11 @@ declare function waitAppReady(duration?: number): Promise<unknown>;
 declare function unzipFile(gzipPath: string, targetFilePath: string): Promise<unknown>;
 declare function zipFile(filePath: string, targetFilePath?: string): Promise<unknown>;
 declare function handleUnexpectedErrors(callback: (err: Error) => void): void;
+declare function parseVersion(version: string): {
+    major: number;
+    minor: number;
+    patch: number;
+    stage: string;
+};
 
-export { getEntryVersion, getGithubFileCdnGroup, getGithubReleaseCdnGroup, getProductAsarPath, getProductVersion, handleUnexpectedErrors, parseGithubCdnURL, requireNative, restartApp, unzipFile, waitAppReady, zipFile };
+export { NoSuchNativeModuleError, getEntryVersion, getGithubFileCdnGroup, getGithubReleaseCdnGroup, getProductAsarPath, getProductVersion, handleUnexpectedErrors, parseGithubCdnURL, parseVersion, requireNative, restartApp, unzipFile, waitAppReady, zipFile };

package/dist/utils.d.ts

@@ -12,9 +12,14 @@ declare function getEntryVersion(): string;
  * @param name - The name of the application
  */
 declare function getProductVersion(name: string): string;
+declare class NoSuchNativeModuleError extends Error {
+    moduleName: string;
+    constructor(moduleName: string);
+}
 /**
  * require native package from app.asar
  * @param packageName native package name
+ * @throws error: {@link NoSuchNativeModuleError}
  */
 declare function requireNative<T = any>(packageName: string): T;
 /**
@@ -40,5 +45,11 @@ declare function waitAppReady(duration?: number): Promise<unknown>;
 declare function unzipFile(gzipPath: string, targetFilePath: string): Promise<unknown>;
 declare function zipFile(filePath: string, targetFilePath?: string): Promise<unknown>;
 declare function handleUnexpectedErrors(callback: (err: Error) => void): void;
+declare function parseVersion(version: string): {
+    major: number;
+    minor: number;
+    patch: number;
+    stage: string;
+};
 
-export { getEntryVersion, getGithubFileCdnGroup, getGithubReleaseCdnGroup, getProductAsarPath, getProductVersion, handleUnexpectedErrors, parseGithubCdnURL, requireNative, restartApp, unzipFile, waitAppReady, zipFile };
+export { NoSuchNativeModuleError, getEntryVersion, getGithubFileCdnGroup, getGithubReleaseCdnGroup, getProductAsarPath, getProductVersion, handleUnexpectedErrors, parseGithubCdnURL, parseVersion, requireNative, restartApp, unzipFile, waitAppReady, zipFile };

package/dist/utils.js

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
+  NoSuchNativeModuleError: () => NoSuchNativeModuleError,
   getEntryVersion: () => getEntryVersion,
   getGithubFileCdnGroup: () => getGithubFileCdnGroup,
   getGithubReleaseCdnGroup: () => getGithubReleaseCdnGroup,
@@ -27,6 +28,7 @@ __export(utils_exports, {
   getProductVersion: () => getProductVersion,
   handleUnexpectedErrors: () => handleUnexpectedErrors,
   parseGithubCdnURL: () => parseGithubCdnURL,
+  parseVersion: () => parseVersion,
   requireNative: () => requireNative,
   restartApp: () => restartApp,
   unzipFile: () => unzipFile,
@@ -47,9 +49,20 @@ function getEntryVersion() {
 function getProductVersion(name) {
   return import_electron.app.isPackaged ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(getProductAsarPath(name), "version"), "utf-8") : getEntryVersion();
 }
+var NoSuchNativeModuleError = class extends Error {
+  moduleName;
+  constructor(moduleName) {
+    super(`no such native module: ${moduleName}`);
+    this.moduleName = moduleName;
+  }
+};
 function requireNative(packageName) {
   const path = import_electron.app.isPackaged ? (0, import_node_path.join)(import_electron.app.getAppPath(), "node_modules", packageName) : packageName;
-  return require(path);
+  try {
+    return require(path);
+  } catch (error) {
+    throw new NoSuchNativeModuleError(packageName);
+  }
 }
 function parseGithubCdnURL(repository, cdnPrefix, relativeFilePath) {
   if (!repository.startsWith("https://github.com/")) {
@@ -141,8 +154,21 @@ function handleUnexpectedErrors(callback) {
   process.on("uncaughtException", listener);
   process.on("unhandledRejection", listener);
 }
+function parseVersion(version) {
+  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
+  const match = semver.exec(version);
+  if (!match) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  const [major, minor, patch] = match.slice(1, 4).map(Number);
+  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return { major, minor, patch, stage: match[4] };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NoSuchNativeModuleError,
   getEntryVersion,
   getGithubFileCdnGroup,
   getGithubReleaseCdnGroup,
@@ -150,6 +176,7 @@ function handleUnexpectedErrors(callback) {
   getProductVersion,
   handleUnexpectedErrors,
   parseGithubCdnURL,
+  parseVersion,
   requireNative,
   restartApp,
   unzipFile,

package/dist/utils.mjs

@@ -1,4 +1,5 @@
 import {
+  NoSuchNativeModuleError,
   getEntryVersion,
   getGithubFileCdnGroup,
   getGithubReleaseCdnGroup,
@@ -6,13 +7,15 @@ import {
   getProductVersion,
   handleUnexpectedErrors,
   parseGithubCdnURL,
+  parseVersion,
   requireNative,
   restartApp,
   unzipFile,
   waitAppReady,
   zipFile
-} from "./chunk-67MCNA7W.mjs";
+} from "./chunk-SWXNCK6H.mjs";
 export {
+  NoSuchNativeModuleError,
   getEntryVersion,
   getGithubFileCdnGroup,
   getGithubReleaseCdnGroup,
@@ -20,6 +23,7 @@ export {
   getProductVersion,
   handleUnexpectedErrors,
   parseGithubCdnURL,
+  parseVersion,
   requireNative,
   restartApp,
   unzipFile,

package/dist/vite.d.mts

@@ -1,5 +1,6 @@
 import { Plugin } from 'vite';
 import { Buffer } from 'node:buffer';
+import { U as UpdateJSON } from './updateJson-7e45d9e1.js';
 
 type DistinguishedName = {
     countryName?: string;
@@ -14,7 +15,8 @@ type DistinguishedName = {
     businessCategory?: string;
     emailAddress?: string;
 };
-type FunctionGenerateSignature = (buffer: Buffer, privateKey: string, cert: string, version: string) => string;
+type FunctionGenerateSignature = (buffer: Buffer, privateKey: string, cert: string, version: string) => string | Promise<string>;
+type FunctionGenerateVersionJson = (existingJson: UpdateJSON, buffer: Buffer, signature: string, version: string, minVersion: string) => UpdateJSON | Promise<UpdateJSON>;
 type Options = {
     /**
      * whether is in build mode
@@ -32,6 +34,11 @@ type Options = {
      * you can set as 'version' in `package.json`
      */
     version: string;
+    /**
+     * mini version of entry
+     * @default version
+     */
+    minimumVersion?: string;
     /**
      * Whether to minify entry file
      */
@@ -55,6 +62,11 @@ type Options = {
          * @default `release/${productName}.asar`
          */
         asarOutputPath?: string;
+        /**
+         * Path to version info output, content is {@link UpdateJSON}
+         * @default `version.json`
+         */
+        versionPath?: string;
         /**
          * Path to gzipped asar file
          * @default `release/${productName}-${version}.asar.gz`
@@ -70,11 +82,6 @@ type Options = {
          * @default `dist`
          */
         rendererDistPath?: string;
-        /**
-         * Path to version info output
-         * @default `version.json`
-         */
-        versionPath?: string;
     };
     /**
      * signature config
@@ -124,6 +131,13 @@ type Options = {
              * @param cert certificate
              */
             generateSignature?: FunctionGenerateSignature;
+            /**
+             * custom signature generate function {@link FunctionGenerateVersionJson}
+             * @param signature generated signature
+             * @param version currentVersion
+             * @param cert certificate
+             */
+            generateVersionJson?: FunctionGenerateVersionJson;
         };
     };
 };