electron-incremental-update 0.7.6 → 0.7.8

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

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/vite.ts
@@ -37,6 +27,8 @@ 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");
 
 // src/crypto.ts
@@ -77,25 +69,26 @@ async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
     });
   });
 }
-
-// src/build-plugins/build.ts
-async function pack(dir, target) {
-  let asar = null;
-  try {
-    asar = await import("asar");
-  } catch (ignore) {
-  }
-  if (!asar) {
-    try {
-      asar = await import("@electron/asar");
-    } catch (ignore) {
-    }
+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}`);
   }
-  if (!asar) {
-    throw new Error("no asar, please install @electron/asar");
+  const [major, minor, patch] = match.slice(1, 4).map(Number);
+  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+    throw new TypeError(`invalid version: ${version}`);
   }
-  await asar.createPackage(dir, target);
+  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({
   version,
   asarOutputPath,
@@ -105,7 +98,7 @@ async function buildAsar({
 }) {
   await (0, import_promises.rename)(rendererDistPath, `${electronDistPath}/renderer`);
   await (0, import_promises.writeFile)(`${electronDistPath}/version`, version);
-  await pack(electronDistPath, asarOutputPath);
+  await (0, import_asar.createPackage)(electronDistPath, asarOutputPath);
   await zipFile(asarOutputPath, gzipPath);
 }
 async function buildVersion({
@@ -114,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,
@@ -143,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;
@@ -183,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,
@@ -194,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,
@@ -221,6 +250,7 @@ function parseOptions(options) {
     isBuild,
     productName,
     version,
+    minimumVersion = version,
     minify = false,
     paths: {
       entryPath = "electron/app.ts",
@@ -239,7 +269,7 @@ function parseOptions(options) {
       overrideFunctions = {}
     } = {}
   } = options;
-  const { generateSignature } = overrideFunctions;
+  const { generateSignature, generateVersionJson } = overrideFunctions;
   let {
     subject = {
       commonName: productName,
@@ -271,11 +301,13 @@ function parseOptions(options) {
     });
     buildVersionOption = {
       version,
+      minimumVersion,
       gzipPath,
       privateKey,
       cert,
       versionPath,
-      generateSignature
+      generateSignature,
+      generateVersionJson
     };
   }
   return { isBuild, buildAsarOption, buildEntryOption, buildVersionOption };

package/dist/vite.mjs

@@ -1,33 +1,20 @@
 import {
+  isUpdateJSON,
   signature
-} from "./chunk-Q2K52LOG.mjs";
+} from "./chunk-2XHZMWRR.mjs";
 import {
+  parseVersion,
   zipFile
-} from "./chunk-67MCNA7W.mjs";
+} from "./chunk-SWXNCK6H.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 pack(dir, target) {
-  let asar = null;
-  try {
-    asar = await import("asar");
-  } catch (ignore) {
-  }
-  if (!asar) {
-    try {
-      asar = await import("@electron/asar");
-    } catch (ignore) {
-    }
-  }
-  if (!asar) {
-    throw new Error("no asar, please install @electron/asar");
-  }
-  await asar.createPackage(dir, target);
-}
 async function buildAsar({
   version,
   asarOutputPath,
@@ -37,7 +24,7 @@ async function buildAsar({
 }) {
   await rename(rendererDistPath, `${electronDistPath}/renderer`);
   await writeFile(`${electronDistPath}/version`, version);
-  await pack(electronDistPath, asarOutputPath);
+  await createPackage(electronDistPath, asarOutputPath);
   await zipFile(asarOutputPath, gzipPath);
 }
 async function buildVersion({
@@ -46,15 +33,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,
@@ -75,15 +98,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",
@@ -126,8 +149,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");
@@ -153,6 +176,7 @@ function parseOptions(options) {
     isBuild,
     productName,
     version,
+    minimumVersion = version,
     minify = false,
     paths: {
       entryPath = "electron/app.ts",
@@ -171,7 +195,7 @@ function parseOptions(options) {
       overrideFunctions = {}
     } = {}
   } = options;
-  const { generateSignature } = overrideFunctions;
+  const { generateSignature, generateVersionJson } = overrideFunctions;
   let {
     subject = {
       commonName: productName,
@@ -203,11 +227,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.6",
+  "version": "0.7.8",
   "description": "electron incremental update tools, powered by vite",
   "scripts": {
     "build": "tsup && node fix-module.js",
@@ -43,10 +43,8 @@
     "updater"
   ],
   "devDependencies": {
-    "@electron/asar": "^3.2.4",
     "@subframe7536/eslint-config": "^0.1.9",
     "@types/node": "^20.3.2",
-    "asar": "^3.2.0",
     "bumpp": "^9.1.1",
     "electron": "^25.2.0",
     "eslint": "^8.43.0",
@@ -56,6 +54,7 @@
     "vitest": "^0.32.2"
   },
   "dependencies": {
+    "@electron/asar": "^3.2.4",
     "ci-info": "^3.8.0",
     "selfsigned": "^2.1.1"
   }