electron-incremental-update 0.7.7 → 0.7.8

package/dist/index.mjs

@@ -1,13 +1,16 @@
 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";
@@ -23,13 +26,6 @@ import { rm, writeFile } from "node:fs/promises";
 // 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) => {
@@ -92,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) {
@@ -118,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,
@@ -126,6 +126,7 @@ function createUpdater(updaterOptions) {
     releaseAsarURL: _release,
     updateJsonURL: _update,
     debug = false,
+    receiveBeta = false,
     downloadConfig: { extraHeader, userAgent } = {},
     overrideFunctions: {
       compareVersion,
@@ -143,11 +144,15 @@ function createUpdater(updaterOptions) {
   function log(msg) {
     debug && updater.emit("debug", msg);
   }
-  function needUpdate(version2) {
-    const currentVersion = getEntryVersion();
-    log(`check update: current version is ${currentVersion}, new version is ${version2}`);
-    const _compare = compareVersion ?? compareVersionDefault;
-    return _compare(currentVersion, version2);
+  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);
+    }
+    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)) {
@@ -162,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";
@@ -202,16 +207,29 @@ function createUpdater(updaterOptions) {
       }
       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.debugMode = debug;
+  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 {
@@ -234,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}`);
@@ -297,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;
         };
     };
 };

package/dist/vite.d.ts

@@ -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;
         };
     };
 };

package/dist/vite.js

@@ -27,6 +27,7 @@ var import_vite = require("vite");
 
 // src/build-plugins/build.ts
 var import_promises = require("fs/promises");
+var import_node_fs2 = require("fs");
 var import_asar = require("@electron/asar");
 var import_esbuild = require("esbuild");
 
@@ -68,6 +69,24 @@ async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
     });
   });
 }
+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/updateJson.ts
+function isUpdateJSON(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/build-plugins/build.ts
 async function buildAsar({
@@ -88,15 +107,51 @@ async function buildVersion({
   privateKey,
   cert,
   version,
-  generateSignature
+  minimumVersion,
+  generateSignature,
+  generateVersionJson
 }) {
+  let _json = {
+    beta: {
+      minimumVersion: version,
+      signature: "",
+      size: 0,
+      version
+    },
+    minimumVersion: version,
+    signature: "",
+    size: 0,
+    version
+  };
+  if ((0, import_node_fs2.existsSync)(versionPath)) {
+    try {
+      _json = JSON.parse(await (0, import_promises.readFile)(versionPath, "utf-8"));
+    } catch (error) {
+    }
+  }
+  if (!isUpdateJSON(_json)) {
+    throw new Error("invalid version file");
+  }
   const buffer = await (0, import_promises.readFile)(gzipPath);
-  const _func = generateSignature ?? signature;
-  await (0, import_promises.writeFile)(versionPath, JSON.stringify({
-    signature: _func(buffer, privateKey, cert, version),
-    version,
-    size: buffer.length
-  }, null, 2));
+  const sig = await (generateSignature ?? signature)(buffer, privateKey, cert, version);
+  if (generateVersionJson) {
+    _json = await generateVersionJson(_json, buffer, sig, version, minimumVersion);
+    if (!isUpdateJSON(_json)) {
+      throw new Error("invalid version info");
+    }
+  } else {
+    _json.beta.version = version;
+    _json.beta.minimumVersion = minimumVersion;
+    _json.beta.signature = sig;
+    _json.beta.size = buffer.length;
+    if (!parseVersion(version).stage) {
+      _json.version = version;
+      _json.minimumVersion = minimumVersion;
+      _json.signature = sig;
+      _json.size = buffer.length;
+    }
+  }
+  await (0, import_promises.writeFile)(versionPath, JSON.stringify(_json, null, 2));
 }
 async function buildEntry({
   entryPath,
@@ -117,25 +172,25 @@ async function buildEntry({
 var import_ci_info = require("ci-info");
 
 // src/build-plugins/key.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_node_path2 = require("path");
 var import_node_os = require("os");
 var import_selfsigned = require("selfsigned");
 function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
   const privateKeyDir = (0, import_node_path2.dirname)(privateKeyPath);
-  (0, import_node_fs2.existsSync)(privateKeyDir) || (0, import_node_fs2.mkdirSync)(privateKeyDir, { recursive: true });
+  (0, import_node_fs3.existsSync)(privateKeyDir) || (0, import_node_fs3.mkdirSync)(privateKeyDir, { recursive: true });
   const certDir = (0, import_node_path2.dirname)(certPath);
-  (0, import_node_fs2.existsSync)(certDir) || (0, import_node_fs2.mkdirSync)(certDir, { recursive: true });
+  (0, import_node_fs3.existsSync)(certDir) || (0, import_node_fs3.mkdirSync)(certDir, { recursive: true });
   const { cert, private: privateKey } = (0, import_selfsigned.generate)(subject, {
     keySize: keyLength,
     algorithm: "sha256",
     days
   });
-  (0, import_node_fs2.writeFileSync)(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
-  (0, import_node_fs2.writeFileSync)(certPath, cert.replace(/\r\n?/g, "\n"));
+  (0, import_node_fs3.writeFileSync)(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
+  (0, import_node_fs3.writeFileSync)(certPath, cert.replace(/\r\n?/g, "\n"));
 }
 function writeCertToMain(entryPath, cert) {
-  const file = (0, import_node_fs2.readFileSync)(entryPath, "utf-8");
+  const file = (0, import_node_fs3.readFileSync)(entryPath, "utf-8");
   const regex = /const SIGNATURE_CERT = ['`][\s\S]*?['`]/;
   const replacement = `const SIGNATURE_CERT = \`${cert}\``;
   let replaced = file;
@@ -157,7 +212,7 @@ function writeCertToMain(entryPath, cert) {
     !isMatched && lines.push(r);
     replaced = lines.join(import_node_os.EOL);
   }
-  (0, import_node_fs2.writeFileSync)(entryPath, replaced.replace(/\r\n?/g, "\n"));
+  (0, import_node_fs3.writeFileSync)(entryPath, replaced.replace(/\r\n?/g, "\n"));
 }
 function parseKeys({
   keyLength,
@@ -168,12 +223,12 @@ function parseKeys({
   days
 }) {
   const keysDir = (0, import_node_path2.dirname)(privateKeyPath);
-  !(0, import_node_fs2.existsSync)(keysDir) && (0, import_node_fs2.mkdirSync)(keysDir);
-  if (!(0, import_node_fs2.existsSync)(privateKeyPath) || !(0, import_node_fs2.existsSync)(certPath)) {
+  !(0, import_node_fs3.existsSync)(keysDir) && (0, import_node_fs3.mkdirSync)(keysDir);
+  if (!(0, import_node_fs3.existsSync)(privateKeyPath) || !(0, import_node_fs3.existsSync)(certPath)) {
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
-  const privateKey = (0, import_node_fs2.readFileSync)(privateKeyPath, "utf-8");
-  const cert = (0, import_node_fs2.readFileSync)(certPath, "utf-8");
+  const privateKey = (0, import_node_fs3.readFileSync)(privateKeyPath, "utf-8");
+  const cert = (0, import_node_fs3.readFileSync)(certPath, "utf-8");
   writeCertToMain(entryPath, cert);
   return {
     privateKey,
@@ -195,6 +250,7 @@ function parseOptions(options) {
     isBuild,
     productName,
     version,
+    minimumVersion = version,
     minify = false,
     paths: {
       entryPath = "electron/app.ts",
@@ -213,7 +269,7 @@ function parseOptions(options) {
       overrideFunctions = {}
     } = {}
   } = options;
-  const { generateSignature } = overrideFunctions;
+  const { generateSignature, generateVersionJson } = overrideFunctions;
   let {
     subject = {
       commonName: productName,
@@ -245,11 +301,13 @@ function parseOptions(options) {
     });
     buildVersionOption = {
       version,
+      minimumVersion,
       gzipPath,
       privateKey,
       cert,
       versionPath,
-      generateSignature
+      generateSignature,
+      generateVersionJson
     };
   }
   return { isBuild, buildAsarOption, buildEntryOption, buildVersionOption };