electron-incremental-update 0.7.7 → 0.7.9

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/")) {
@@ -98,11 +111,11 @@ function waitAppReady(duration = 1e3) {
     }, duration);
     import_electron.app.whenReady().then(() => {
       clearTimeout(timeout);
-      resolve(null);
+      resolve();
     });
   });
 }
-async function unzipFile(gzipPath, targetFilePath) {
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
   if (!(0, import_node_fs.existsSync)(gzipPath)) {
     throw new Error(`path to zipped file not exist: ${gzipPath}`);
   }
@@ -141,8 +154,33 @@ 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);
+  const ret = {
+    major,
+    minor,
+    patch,
+    stage: "",
+    stageVersion: -1
+  };
+  if (match[4]) {
+    let [stage, _v] = match[4].split(".");
+    ret.stage = stage;
+    ret.stageVersion = Number(_v) || -1;
+  }
+  if (isNaN(major) || isNaN(minor) || isNaN(patch) || isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return ret;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NoSuchNativeModuleError,
   getEntryVersion,
   getGithubFileCdnGroup,
   getGithubReleaseCdnGroup,
@@ -150,6 +188,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,16 @@ import {
   getProductVersion,
   handleUnexpectedErrors,
   parseGithubCdnURL,
+  parseVersion,
   requireNative,
   restartApp,
   unzipFile,
   waitAppReady,
   zipFile
-} from "./chunk-67MCNA7W.mjs";
+} from "./chunk-4TION32M.mjs";
+import "./chunk-ZFXKCRJC.mjs";
 export {
+  NoSuchNativeModuleError,
   getEntryVersion,
   getGithubFileCdnGroup,
   getGithubReleaseCdnGroup,
@@ -20,6 +24,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 { UpdateJSON } from './updateJson.mjs';
 
 type DistinguishedName = {
     countryName?: string;
@@ -14,7 +15,26 @@ type DistinguishedName = {
     businessCategory?: string;
     emailAddress?: string;
 };
-type FunctionGenerateSignature = (buffer: Buffer, privateKey: string, cert: string, version: string) => string;
+type GeneratorOverrideFunctions = {
+    /**
+     * custom signature generate function
+     * @param buffer file buffer
+     * @param privateKey private key
+     * @param cert certificate string, **EOL must be '\n'**
+     * @param version current version
+     */
+    generateSignature?: (buffer: Buffer, privateKey: string, cert: string, version: string) => string | Promise<string>;
+    /**
+     * custom generate version json function
+     * @param existingJson The existing JSON object.
+     * @param buffer file buffer
+     * @param signature generated signature
+     * @param version current version
+     * @param minVersion The minimum version
+     * @returns The updated version json
+     */
+    generateVersionJson?: (existingJson: UpdateJSON, buffer: Buffer, signature: string, version: string, minVersion: string) => UpdateJSON | Promise<UpdateJSON>;
+};
 type Options = {
     /**
      * whether is in build mode
@@ -32,6 +52,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 +80,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 +100,6 @@ type Options = {
          * @default `dist`
          */
         rendererDistPath?: string;
-        /**
-         * Path to version info output
-         * @default `version.json`
-         */
-        versionPath?: string;
     };
     /**
      * signature config
@@ -116,15 +141,7 @@ type Options = {
              */
             days?: number;
         };
-        overrideFunctions?: {
-            /**
-             * custom signature generate function {@link FunctionGenerateSignature}
-             * @param buffer file buffer
-             * @param privateKey private key
-             * @param cert certificate
-             */
-            generateSignature?: FunctionGenerateSignature;
-        };
+        overrideFunctions?: GeneratorOverrideFunctions;
     };
 };
 

package/dist/vite.d.ts

@@ -1,5 +1,6 @@
 import { Plugin } from 'vite';
 import { Buffer } from 'node:buffer';
+import { UpdateJSON } from './updateJson.js';
 
 type DistinguishedName = {
     countryName?: string;
@@ -14,7 +15,26 @@ type DistinguishedName = {
     businessCategory?: string;
     emailAddress?: string;
 };
-type FunctionGenerateSignature = (buffer: Buffer, privateKey: string, cert: string, version: string) => string;
+type GeneratorOverrideFunctions = {
+    /**
+     * custom signature generate function
+     * @param buffer file buffer
+     * @param privateKey private key
+     * @param cert certificate string, **EOL must be '\n'**
+     * @param version current version
+     */
+    generateSignature?: (buffer: Buffer, privateKey: string, cert: string, version: string) => string | Promise<string>;
+    /**
+     * custom generate version json function
+     * @param existingJson The existing JSON object.
+     * @param buffer file buffer
+     * @param signature generated signature
+     * @param version current version
+     * @param minVersion The minimum version
+     * @returns The updated version json
+     */
+    generateVersionJson?: (existingJson: UpdateJSON, buffer: Buffer, signature: string, version: string, minVersion: string) => UpdateJSON | Promise<UpdateJSON>;
+};
 type Options = {
     /**
      * whether is in build mode
@@ -32,6 +52,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 +80,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 +100,6 @@ type Options = {
          * @default `dist`
          */
         rendererDistPath?: string;
-        /**
-         * Path to version info output
-         * @default `version.json`
-         */
-        versionPath?: string;
     };
     /**
      * signature config
@@ -116,15 +141,7 @@ type Options = {
              */
             days?: number;
         };
-        overrideFunctions?: {
-            /**
-             * custom signature generate function {@link FunctionGenerateSignature}
-             * @param buffer file buffer
-             * @param privateKey private key
-             * @param cert certificate
-             */
-            generateSignature?: FunctionGenerateSignature;
-        };
+        overrideFunctions?: GeneratorOverrideFunctions;
     };
 };
 

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,36 @@ 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);
+  const ret = {
+    major,
+    minor,
+    patch,
+    stage: "",
+    stageVersion: -1
+  };
+  if (match[4]) {
+    let [stage, _v] = match[4].split(".");
+    ret.stage = stage;
+    ret.stageVersion = Number(_v) || -1;
+  }
+  if (isNaN(major) || isNaN(minor) || isNaN(patch) || isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return ret;
+}
+
+// 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 +119,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 +184,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 +224,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 +235,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 +262,7 @@ function parseOptions(options) {
     isBuild,
     productName,
     version,
+    minimumVersion = version,
     minify = false,
     paths: {
       entryPath = "electron/app.ts",
@@ -213,7 +281,7 @@ function parseOptions(options) {
       overrideFunctions = {}
     } = {}
   } = options;
-  const { generateSignature } = overrideFunctions;
+  const { generateSignature, generateVersionJson } = overrideFunctions;
   let {
     subject = {
       commonName: productName,
@@ -245,11 +313,13 @@ function parseOptions(options) {
     });
     buildVersionOption = {
       version,
+      minimumVersion,
       gzipPath,
       privateKey,
       cert,
       versionPath,
-      generateSignature
+      generateSignature,
+      generateVersionJson
     };
   }
   return { isBuild, buildAsarOption, buildEntryOption, buildVersionOption };

package/dist/vite.mjs

@@ -2,14 +2,20 @@ import {
   signature
 } from "./chunk-Q2K52LOG.mjs";
 import {
+  parseVersion,
   zipFile
-} from "./chunk-67MCNA7W.mjs";
+} from "./chunk-4TION32M.mjs";
+import {
+  isUpdateJSON
+} from "./chunk-2JVXVTC5.mjs";
+import "./chunk-ZFXKCRJC.mjs";
 
 // src/vite.ts
 import { createLogger } from "vite";
 
 // src/build-plugins/build.ts
 import { readFile, rename, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { createPackage } from "@electron/asar";
 import { build } from "esbuild";
 async function buildAsar({
@@ -30,15 +36,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 (existsSync(versionPath)) {
+    try {
+      _json = JSON.parse(await readFile(versionPath, "utf-8"));
+    } catch (error) {
+    }
+  }
+  if (!isUpdateJSON(_json)) {
+    throw new Error("invalid version file");
+  }
   const buffer = await readFile(gzipPath);
-  const _func = generateSignature ?? signature;
-  await 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 writeFile(versionPath, JSON.stringify(_json, null, 2));
 }
 async function buildEntry({
   entryPath,
@@ -59,15 +101,15 @@ async function buildEntry({
 import { isCI } from "ci-info";
 
 // src/build-plugins/key.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { EOL } from "node:os";
 import { generate } from "selfsigned";
 function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
   const privateKeyDir = dirname(privateKeyPath);
-  existsSync(privateKeyDir) || mkdirSync(privateKeyDir, { recursive: true });
+  existsSync2(privateKeyDir) || mkdirSync(privateKeyDir, { recursive: true });
   const certDir = dirname(certPath);
-  existsSync(certDir) || mkdirSync(certDir, { recursive: true });
+  existsSync2(certDir) || mkdirSync(certDir, { recursive: true });
   const { cert, private: privateKey } = generate(subject, {
     keySize: keyLength,
     algorithm: "sha256",
@@ -110,8 +152,8 @@ function parseKeys({
   days
 }) {
   const keysDir = dirname(privateKeyPath);
-  !existsSync(keysDir) && mkdirSync(keysDir);
-  if (!existsSync(privateKeyPath) || !existsSync(certPath)) {
+  !existsSync2(keysDir) && mkdirSync(keysDir);
+  if (!existsSync2(privateKeyPath) || !existsSync2(certPath)) {
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
   const privateKey = readFileSync(privateKeyPath, "utf-8");
@@ -137,6 +179,7 @@ function parseOptions(options) {
     isBuild,
     productName,
     version,
+    minimumVersion = version,
     minify = false,
     paths: {
       entryPath = "electron/app.ts",
@@ -155,7 +198,7 @@ function parseOptions(options) {
       overrideFunctions = {}
     } = {}
   } = options;
-  const { generateSignature } = overrideFunctions;
+  const { generateSignature, generateVersionJson } = overrideFunctions;
   let {
     subject = {
       commonName: productName,
@@ -187,11 +230,13 @@ function parseOptions(options) {
     });
     buildVersionOption = {
       version,
+      minimumVersion,
       gzipPath,
       privateKey,
       cert,
       versionPath,
-      generateSignature
+      generateSignature,
+      generateVersionJson
     };
   }
   return { isBuild, buildAsarOption, buildEntryOption, buildVersionOption };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "electron-incremental-update",
   "author": "subframe7536",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "electron incremental update tools, powered by vite",
   "scripts": {
     "build": "tsup && node fix-module.js",
@@ -58,4 +58,4 @@
     "ci-info": "^3.8.0",
     "selfsigned": "^2.1.1"
   }
-}
+}