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

package/dist/vite.js

@@ -1,18 +1,20 @@
-// src/vite.ts
-import { basename as basename2, join as join2, resolve } from "node:path";
-import { cpSync, existsSync as existsSync4, rmSync } from "node:fs";
-import { mergeConfig as mergeConfig2, normalizePath as normalizePath2 } from "vite";
-import ElectronSimple from "vite-plugin-electron/simple";
-import { startup } from "vite-plugin-electron";
-import { notBundle } from "vite-plugin-electron/plugin";
-import { loadPackageJSON } from "local-pkg";
+import path2, { join, resolve, basename, dirname } from 'node:path';
+import fs, { rmSync, renameSync, writeFileSync, readFileSync, existsSync, cpSync, mkdirSync } from 'node:fs';
+import { createLogger, normalizePath, mergeConfig, createFilter } from 'vite';
+import ElectronSimple from 'vite-plugin-electron/simple';
+import { startup } from 'vite-plugin-electron';
+import { notBundle } from 'vite-plugin-electron/plugin';
+import { getPackageInfoSync, loadPackageJSON } from 'local-pkg';
+import Asar from '@electron/asar';
+import { build } from 'esbuild';
+import { spawn } from 'node:child_process';
+import * as babel from '@babel/core';
+import MagicString from 'magic-string';
+import { brotliCompress } from 'node:zlib';
+import { createSign, createPrivateKey, createHash, createCipheriv } from 'node:crypto';
+import { generate } from 'selfsigned';
 
-// src/build-plugins/build.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename, join } from "node:path";
-import Asar from "@electron/asar";
-import { build } from "esbuild";
-import { mergeConfig } from "vite";
+// src/vite.ts
 
 // src/utils/version.ts
 function parseVersion(version) {
@@ -42,48 +44,21 @@ function isUpdateJSON(json) {
   const is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
   return is(json) && is(json?.beta);
 }
-
-// src/utils/zip.ts
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { brotliCompress } from "node:zlib";
-async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
-  if (!existsSync(filePath)) {
-    throw new Error(`path to be zipped not exist: ${filePath}`);
+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;
   }
-  const buffer = readFileSync(filePath);
-  return new Promise((resolve2, reject) => {
-    brotliCompress(buffer, (err, buffer2) => {
-      if (err) {
-        reject(err);
-      }
-      writeFileSync(targetFilePath, buffer2);
-      resolve2();
-    });
-  });
+  return existingJson;
 }
-
-// src/utils/crypto/utils.ts
-import { createHash } from "node:crypto";
-function hashString(data, length) {
-  const hash = createHash("SHA256").update(data).digest("binary");
-  return Buffer.from(hash).subarray(0, length);
-}
-
-// src/utils/crypto/encrypt.ts
-import { createCipheriv, createPrivateKey, createSign } from "node:crypto";
-function encrypt(plainText, key, iv) {
-  const cipher = 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 = createSign("RSA-SHA256").update(buffer).sign(createPrivateKey(privateKey), "base64");
-  return encrypt(`${sig}%${version}`, hashString(cert, 32), hashString(buffer, 16));
-}
-
-// src/build-plugins/constant.ts
-import { createLogger } from "vite";
 var id = "electron-incremental-updater";
 var bytecodeId = `${id}-bytecode`;
 var log = createLogger("info", { prefix: `[${id}]` });
@@ -92,14 +67,6 @@ var bytecodeLog = createLogger("info", { prefix: `[${bytecodeId}]` });
 // src/build-plugins/bytecode/code.ts
 var bytecodeGeneratorScript = "const vm = require('vm')\nconst v8 = require('v8')\nconst wrap = require('module').wrap\nv8.setFlagsFromString('--no-lazy')\nv8.setFlagsFromString('--no-flush-bytecode')\nlet code = ''\nprocess.stdin.setEncoding('utf-8')\nprocess.stdin.on('readable', () => {\n  const data = process.stdin.read()\n  if (data !== null) {\n    code += data\n  }\n})\nprocess.stdin.on('end', () => {\n  try {\n    if (typeof code !== 'string') {\n      throw new Error('javascript code must be string.')\n    }\n    const script = new vm.Script(wrap(code), { produceCachedData: true })\n    const bytecodeBuffer = script.createCachedData()\n    process.stdout.write(bytecodeBuffer)\n  } catch (error) {\n    console.error(error)\n  }\n})\n";
 var bytecodeModuleLoaderCode = '"use strict";\nconst fs = require("fs");\nconst path = require("path");\nconst vm = require("vm");\nconst v8 = require("v8");\nconst Module = require("module");\nv8.setFlagsFromString("--no-lazy");\nv8.setFlagsFromString("--no-flush-bytecode");\nconst FLAG_HASH_OFFSET = 12;\nconst SOURCE_HASH_OFFSET = 8;\nlet dummyBytecode;\nfunction setFlagHashHeader(bytecodeBuffer) {\n  if (!dummyBytecode) {\n    const script = new vm.Script("", {\n      produceCachedData: true\n    });\n    dummyBytecode = script.createCachedData();\n  }\n  dummyBytecode.slice(FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4).copy(bytecodeBuffer, FLAG_HASH_OFFSET);\n};\nfunction getSourceHashHeader(bytecodeBuffer) {\n  return bytecodeBuffer.slice(SOURCE_HASH_OFFSET, SOURCE_HASH_OFFSET + 4);\n};\nfunction buffer2Number(buffer) {\n  let ret = 0;\n  ret |= buffer[3] << 24;\n  ret |= buffer[2] << 16;\n  ret |= buffer[1] << 8;\n  ret |= buffer[0];\n  return ret;\n};\nModule._extensions[".jsc"] = Module._extensions[".cjsc"] = function (module, filename) {\n  const bytecodeBuffer = fs.readFileSync(filename);\n  if (!Buffer.isBuffer(bytecodeBuffer)) {\n    throw new Error("BytecodeBuffer must be a buffer object.");\n  }\n  setFlagHashHeader(bytecodeBuffer);\n  const length = buffer2Number(getSourceHashHeader(bytecodeBuffer));\n  let dummyCode = "";\n  if (length > 1) {\n    dummyCode = "\\"" + "\\u200b".repeat(length - 2) + "\\"";\n  }\n  const script = new vm.Script(dummyCode, {\n    filename: filename,\n    lineOffset: 0,\n    displayErrors: true,\n    cachedData: bytecodeBuffer\n  });\n  if (script.cachedDataRejected) {\n    throw new Error("Invalid or incompatible cached data (cachedDataRejected)");\n  }\n  const require = function (id) {\n    return module.require(id);\n  };\n  require.resolve = function (request, options) {\n    return Module._resolveFilename(request, module, false, options);\n  };\n  if (process.mainModule) {\n    require.main = process.mainModule;\n  }\n  require.extensions = Module._extensions;\n  require.cache = Module._cache;\n  const compiledWrapper = script.runInThisContext({\n    filename: filename,\n    lineOffset: 0,\n    columnOffset: 0,\n    displayErrors: true\n  });\n  const dirname = path.dirname(filename);\n  const args = [module.exports, require, module, filename, dirname, process, global];\n  return compiledWrapper.apply(module.exports, args);\n};\n';
-
-// src/build-plugins/bytecode/utils.ts
-import path from "node:path";
-import fs from "node:fs";
-import { spawn } from "node:child_process";
-import * as babel from "@babel/core";
-import MagicString from "magic-string";
-import { getPackageInfoSync } from "local-pkg";
 var electronModulePath = getPackageInfoSync("electron")?.rootPath;
 var useStrict = "'use strict';";
 var bytecodeModuleLoader = "__loader__.js";
@@ -109,13 +76,13 @@ function getElectronPath() {
     if (!electronModulePath) {
       throw new Error("Electron is not installed");
     }
-    const pathFile = path.join(electronModulePath, "path.txt");
+    const pathFile = path2.join(electronModulePath, "path.txt");
     let executablePath;
     if (fs.existsSync(pathFile)) {
       executablePath = fs.readFileSync(pathFile, "utf-8");
     }
     if (executablePath) {
-      electronExecPath = path.join(electronModulePath, "dist", executablePath);
+      electronExecPath = path2.join(electronModulePath, "dist", executablePath);
       process.env.ELECTRON_EXEC_PATH = electronExecPath;
     } else {
       throw new Error("Electron executable file is not existed");
@@ -124,14 +91,14 @@ function getElectronPath() {
   return electronExecPath;
 }
 function getBytecodeCompilerPath() {
-  const scriptPath = path.join(electronModulePath, "bytenode.cjs");
+  const scriptPath = path2.join(electronModulePath, "bytenode.cjs");
   if (!fs.existsSync(scriptPath)) {
     fs.writeFileSync(scriptPath, bytecodeGeneratorScript);
   }
   return scriptPath;
 }
 function toRelativePath(filename, importer) {
-  const relPath = path.posix.relative(path.dirname(importer), filename);
+  const relPath = path2.posix.relative(path2.dirname(importer), filename);
   return relPath.startsWith(".") ? relPath : `./${relPath}`;
 }
 function compileToBytecode(code) {
@@ -198,15 +165,17 @@ async function buildAsar({
   asarOutputPath,
   gzipPath,
   electronDistPath,
-  rendererDistPath
+  rendererDistPath,
+  generateGzipFile
 }) {
   renameSync(rendererDistPath, join(electronDistPath, "renderer"));
-  writeFileSync2(join(electronDistPath, "version"), version);
+  writeFileSync(join(electronDistPath, "version"), version);
   await Asar.createPackage(electronDistPath, asarOutputPath);
-  await zipFile(asarOutputPath, gzipPath);
+  const buf = await generateGzipFile(readFileSync(asarOutputPath));
+  writeFileSync(gzipPath, buf);
+  return buf;
 }
 async function buildVersion({
-  gzipPath,
   versionPath,
   privateKey,
   cert,
@@ -214,7 +183,7 @@ async function buildVersion({
   minimumVersion,
   generateSignature,
   generateVersionJson
-}) {
+}, asarBuffer) {
   let _json = {
     beta: {
       minimumVersion: version,
@@ -227,39 +196,23 @@ async function buildVersion({
     size: 0,
     version
   };
-  if (existsSync2(versionPath)) {
+  if (existsSync(versionPath)) {
     try {
-      const oldVersionJson = JSON.parse(readFileSync2(versionPath, "utf-8"));
+      const oldVersionJson = JSON.parse(readFileSync(versionPath, "utf-8"));
       if (isUpdateJSON(oldVersionJson)) {
         _json = oldVersionJson;
       } else {
-        log.warn("old version json is invalid, ignore it");
+        log.warn("old version json is invalid, ignore it", { timestamp: true });
       }
     } catch {
     }
   }
-  const buffer = readFileSync2(gzipPath);
-  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,
-      minimumVersion,
-      signature: sig,
-      size: buffer.length
-    };
-    if (!parseVersion(version).stage) {
-      _json.version = version;
-      _json.minimumVersion = minimumVersion;
-      _json.signature = sig;
-      _json.size = buffer.length;
-    }
+  const sig = await generateSignature(asarBuffer, privateKey, cert, version);
+  _json = await generateVersionJson(_json, asarBuffer, sig, version, minimumVersion);
+  if (!isUpdateJSON(_json)) {
+    throw new Error("invalid version info");
   }
-  writeFileSync2(versionPath, JSON.stringify(_json, null, 2));
+  writeFileSync(versionPath, JSON.stringify(_json, null, 2));
 }
 async function buildEntry({
   sourcemap,
@@ -297,7 +250,7 @@ async function buildEntry({
   }
   const filePaths = Object.keys(metafile?.outputs ?? []);
   for (const filePath of filePaths) {
-    let code = readFileSync2(filePath, "utf-8");
+    let code = readFileSync(filePath, "utf-8");
     const fileName = basename(filePath);
     const isEntry = fileName.endsWith("entry.js");
     if (isEntry) {
@@ -311,8 +264,8 @@ async function buildEntry({
       [...protectedStrings, ...isEntry ? getCert(code) : []]
     ).code;
     const buffer = await compileToBytecode(transformedCode);
-    writeFileSync2(`${filePath}c`, buffer);
-    writeFileSync2(
+    writeFileSync(`${filePath}c`, buffer);
+    writeFileSync(
       filePath,
       `${isEntry ? bytecodeModuleLoaderCode : useStrict}${isEntry ? "" : "module.exports = "}require("./${fileName}c")`
     );
@@ -327,18 +280,36 @@ function getCert(code) {
   const cert = code.match(/-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\\n/)?.[0];
   return cert ? [cert] : [];
 }
-
-// src/build-plugins/key.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname } from "node:path";
-import { generate } from "selfsigned";
+async function defaultZipFile(buffer) {
+  return new Promise((resolve2, reject) => {
+    brotliCompress(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve2(buffer2);
+      }
+    });
+  });
+}
+function hashBuffer(data, length) {
+  const hash = createHash("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
+function aesEncrypt(plainText, key, iv) {
+  const cipher = createCipheriv("aes-256-cbc", key, iv);
+  return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
+}
+function defaultSignature(buffer, privateKey, cert, version) {
+  const sig = createSign("RSA-SHA256").update(buffer).sign(createPrivateKey(privateKey), "base64");
+  return aesEncrypt(`${sig}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
+}
 function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
   const privateKeyDir = dirname(privateKeyPath);
-  if (!existsSync3(privateKeyDir)) {
+  if (!existsSync(privateKeyDir)) {
     mkdirSync(privateKeyDir, { recursive: true });
   }
   const certDir = dirname(certPath);
-  if (!existsSync3(certDir)) {
+  if (!existsSync(certDir)) {
     mkdirSync(certDir, { recursive: true });
   }
   const { cert, private: privateKey } = generate(subject, {
@@ -346,8 +317,8 @@ function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
     algorithm: "sha256",
     days
   });
-  writeFileSync3(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
-  writeFileSync3(certPath, cert.replace(/\r\n?/g, "\n"));
+  writeFileSync(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
+  writeFileSync(certPath, cert.replace(/\r\n?/g, "\n"));
 }
 function parseKeys({
   keyLength,
@@ -357,15 +328,21 @@ function parseKeys({
   days
 }) {
   const keysDir = dirname(privateKeyPath);
-  if (!existsSync3(keysDir)) {
+  let privateKey = process.env.UPDATER_PK;
+  let cert = process.env.UPDATER_CERT;
+  if (privateKey && cert) {
+    log.info("use UPDATER_PK and UPDATER_CERT from environment variables", { timestamp: true });
+    return { privateKey, cert };
+  }
+  if (!existsSync(keysDir)) {
     mkdirSync(keysDir);
   }
-  if (!existsSync3(privateKeyPath) || !existsSync3(certPath)) {
-    log.warn("no key pair found, generate new key pair");
+  if (!existsSync(privateKeyPath) || !existsSync(certPath)) {
+    log.info("no key pair found, generate new key pair", { timestamp: true });
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
-  const privateKey = process.env.UPDATER_PK || readFileSync3(privateKeyPath, "utf-8");
-  const cert = process.env.UPDATER_CERT || readFileSync3(certPath, "utf-8");
+  privateKey = readFileSync(privateKeyPath, "utf-8");
+  cert = readFileSync(certPath, "utf-8");
   return { privateKey, cert };
 }
 function parseSubjects(subject) {
@@ -396,24 +373,27 @@ function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
       privateKeyPath = "keys/private.pem",
       certPath = "keys/cert.pem",
       keyLength = 2048,
-      certInfo = {},
-      overrideGenerator = {}
+      certInfo: {
+        subject = {
+          commonName: pkg.name,
+          organizationName: `org.${pkg.name}`
+        },
+        days = 3650
+      } = {}
+    } = {},
+    overrideGenerator: {
+      generateGzipFile = defaultZipFile,
+      generateSignature = defaultSignature,
+      generateVersionJson = defaultVersionJsonGenerator
     } = {}
   } = options;
-  const { generateSignature, generateVersionJson } = overrideGenerator;
-  let {
-    subject = {
-      commonName: pkg.name,
-      organizationName: `org.${pkg.name}`
-    },
-    days = 3650
-  } = certInfo;
   const buildAsarOption = {
     version: pkg.version,
     asarOutputPath,
     gzipPath,
     electronDistPath,
-    rendererDistPath
+    rendererDistPath,
+    generateGzipFile
   };
   const buildEntryOption = {
     minify: entryMinify ?? minify,
@@ -433,7 +413,6 @@ function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
   const buildVersionOption = {
     version: pkg.version,
     minimumVersion,
-    gzipPath,
     privateKey,
     cert,
     versionPath,
@@ -443,11 +422,18 @@ function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
   return { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert };
 }
 
+// src/build-plugins/utils.ts
+function readableSize(size) {
+  const units = ["B", "KB", "MB", "GB"];
+  let i = 0;
+  while (size >= 1024 && i < units.length - 1) {
+    size /= 1024;
+    i++;
+  }
+  return `${size.toFixed(2)} ${units[i]}`;
+}
+
 // src/build-plugins/bytecode/index.ts
-import path2 from "node:path";
-import fs2 from "node:fs";
-import { createFilter, normalizePath } from "vite";
-import MagicString2 from "magic-string";
 function bytecodePlugin(isBuild, env, options = {}) {
   if (!isBuild) {
     return null;
@@ -525,7 +511,7 @@ function bytecodePlugin(isBuild, env, options = {}) {
             let _code = chunk.code;
             if (bytecodeRE && _code.match(bytecodeRE)) {
               let match;
-              const s = new MagicString2(_code);
+              const s = new MagicString(_code);
               while (match = bytecodeRE.exec(_code)) {
                 const [prefix, chunkName] = match;
                 const len = prefix.length + chunkName.length;
@@ -538,7 +524,7 @@ function bytecodePlugin(isBuild, env, options = {}) {
             const chunkFilePath = path2.resolve(outDir, name);
             if (bytecodeChunks.includes(name)) {
               const bytecodeBuffer = await compileToBytecode(_code);
-              fs2.writeFileSync(path2.resolve(outDir, name + "c"), bytecodeBuffer);
+              fs.writeFileSync(path2.resolve(outDir, name + "c"), bytecodeBuffer);
               if (chunk.isEntry) {
                 const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
                 const bytecodeModuleBlock = `require("./${path2.basename(name) + "c"}");`;
@@ -546,9 +532,9 @@ function bytecodePlugin(isBuild, env, options = {}) {
 ${bytecodeLoaderBlock}
 module.exports=${bytecodeModuleBlock}
 `;
-                fs2.writeFileSync(chunkFilePath, code);
+                fs.writeFileSync(chunkFilePath, code);
               } else {
-                fs2.unlinkSync(chunkFilePath);
+                fs.unlinkSync(chunkFilePath);
               }
               bytecodeFiles.push({ name: name + "c", size: bytecodeBuffer.length });
             } else {
@@ -575,7 +561,7 @@ module.exports=${bytecodeModuleBlock}
                 _code = hasBytecodeMoudle ? _code.replace(useStrict, `${useStrict}
 ${bytecodeLoaderBlock}`) : _code;
               }
-              fs2.writeFileSync(chunkFilePath, _code);
+              fs.writeFileSync(chunkFilePath, _code);
             }
           }
         })
@@ -584,9 +570,8 @@ ${bytecodeLoaderBlock}`) : _code;
     closeBundle() {
       const outDir = `${normalizePath(path2.relative(config.root, path2.resolve(config.root, config.build.outDir)))}/`;
       bytecodeFiles.forEach((file) => {
-        const kbs = file.size / 1e3;
         bytecodeLog.info(
-          `${outDir}${file.name} => ${kbs.toFixed(2)} kB`,
+          `${outDir}${file.name} => ${readableSize(file.size)}`,
           { timestamp: true }
         );
       });
@@ -607,9 +592,9 @@ function debugStartup(args) {
 function getMainFilePath(options) {
   let mainFilePath;
   if (typeof options === "string") {
-    mainFilePath = basename2(options);
+    mainFilePath = basename(options);
   } else if (Array.isArray(options)) {
-    mainFilePath = basename2(options[0]);
+    mainFilePath = basename(options[0]);
   } else {
     const name = options?.index ?? options?.main;
     if (!name) {
@@ -620,7 +605,7 @@ function getMainFilePath(options) {
   return mainFilePath.replace(/\.[cm]?ts$/, ".js");
 }
 function parseVersionPath(versionPath) {
-  versionPath = normalizePath2(versionPath);
+  versionPath = normalizePath(versionPath);
   if (!versionPath.startsWith("./")) {
     versionPath = "./" + versionPath;
   }
@@ -661,8 +646,8 @@ async function electronWithUpdater(options) {
   const { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert } = _options;
   const { entryOutputDirPath, nativeModuleEntryMap, appEntryPath } = buildEntryOption;
   sourcemap ??= isBuild || !!process.env.VSCODE_DEBUG;
-  const _appPath = normalizePath2(join2(entryOutputDirPath, "entry.js"));
-  if (resolve(normalizePath2(pkg.main)) !== resolve(_appPath)) {
+  const _appPath = normalizePath(join(entryOutputDirPath, "entry.js"));
+  if (resolve(normalizePath(pkg.main)) !== resolve(_appPath)) {
     throw new Error(`wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath}"`);
   }
   const define = {
@@ -672,7 +657,7 @@ async function electronWithUpdater(options) {
     __EIU_MAIN_DEV_DIR__: JSON.stringify(buildAsarOption.electronDistPath),
     __EIU_MAIN_FILE__: JSON.stringify(getMainFilePath(_main.files)),
     __EIU_SIGNATURE_CERT__: JSON.stringify(cert),
-    __EUI_VERSION_PATH__: JSON.stringify(parseVersionPath(buildVersionOption.versionPath))
+    __EIU_VERSION_PATH__: JSON.stringify(parseVersionPath(buildVersionOption.versionPath))
   };
   const _buildEntry = async () => {
     await buildEntry(
@@ -684,12 +669,12 @@ async function electronWithUpdater(options) {
   };
   const _postBuild = postBuild ? async () => await postBuild({
     getPathFromEntryOutputDir(...paths) {
-      return join2(entryOutputDirPath, ...paths);
+      return join(entryOutputDirPath, ...paths);
     },
     copyToEntryOutputDir({ from, to, skipIfExist = true }) {
-      if (existsSync4(from)) {
-        const target = join2(entryOutputDirPath, to ?? basename2(from));
-        if (!skipIfExist || !existsSync4(target)) {
+      if (existsSync(from)) {
+        const target = join(entryOutputDirPath, to ?? basename(from));
+        if (!skipIfExist || !existsSync(target)) {
           try {
             cpSync(from, target);
           } catch (error) {
@@ -719,7 +704,7 @@ async function electronWithUpdater(options) {
           args.startup();
         }
       },
-      vite: mergeConfig2(
+      vite: mergeConfig(
         {
           plugins: [
             !isBuild && useNotBundle ? notBundle() : void 0,
@@ -739,7 +724,7 @@ async function electronWithUpdater(options) {
     preload: {
       input: _preload.files,
       onstart: _preload.onstart,
-      vite: mergeConfig2(
+      vite: mergeConfig(
         {
           plugins: [
             bytecodeOptions && bytecodePlugin(isBuild, "preload", bytecodeOptions),
@@ -752,9 +737,9 @@ async function electronWithUpdater(options) {
               async closeBundle() {
                 await _buildEntry();
                 await _postBuild();
-                await buildAsar(buildAsarOption);
-                log.info(`build asar to '${buildAsarOption.asarOutputPath}'`, { timestamp: true });
-                await buildVersion(buildVersionOption);
+                const buffer = await buildAsar(buildAsarOption);
+                log.info(`build update asar to '${buildAsarOption.gzipPath}' => ${readableSize(buffer.length)}`, { timestamp: true });
+                await buildVersion(buildVersionOption, buffer);
                 log.info(`build version info to '${buildVersionOption.versionPath}'`, { timestamp: true });
               }
             }
@@ -786,7 +771,7 @@ async function electronWithUpdater(options) {
   }
   let extraHmrPlugin;
   if (nativeModuleEntryMap) {
-    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => resolve(normalizePath2(file)));
+    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => resolve(normalizePath(file)));
     extraHmrPlugin = {
       name: `${id}-dev`,
       apply() {
@@ -806,7 +791,5 @@ async function electronWithUpdater(options) {
   }
   return [ElectronSimple(electronPluginOptions), extraHmrPlugin];
 }
-export {
-  debugStartup,
-  electronWithUpdater
-};
+
+export { debugStartup, electronWithUpdater };

package/dist/zip-WRrEMkgp.d.cts

@@ -0,0 +1,10 @@
+declare function hashBuffer(data: string | Buffer, length: number): Buffer;
+declare function aesEncrypt(plainText: string, key: Buffer, iv: Buffer): string;
+declare function defaultSignature(buffer: Buffer, privateKey: string, cert: string, version: string): string;
+declare function aesDecrypt(encryptedText: string, key: Buffer, iv: Buffer): string;
+declare function defaultVerify(buffer: Buffer, signature: string, cert: string): string | undefined;
+
+declare function defaultZipFile(buffer: Buffer): Promise<Buffer>;
+declare function defaultUnzipFile(buffer: Buffer): Promise<Buffer>;
+
+export { defaultUnzipFile as a, aesEncrypt as b, defaultSignature as c, defaultZipFile as d, aesDecrypt as e, defaultVerify as f, hashBuffer as h };

package/dist/zip-WRrEMkgp.d.ts

@@ -0,0 +1,10 @@
+declare function hashBuffer(data: string | Buffer, length: number): Buffer;
+declare function aesEncrypt(plainText: string, key: Buffer, iv: Buffer): string;
+declare function defaultSignature(buffer: Buffer, privateKey: string, cert: string, version: string): string;
+declare function aesDecrypt(encryptedText: string, key: Buffer, iv: Buffer): string;
+declare function defaultVerify(buffer: Buffer, signature: string, cert: string): string | undefined;
+
+declare function defaultZipFile(buffer: Buffer): Promise<Buffer>;
+declare function defaultUnzipFile(buffer: Buffer): Promise<Buffer>;
+
+export { defaultUnzipFile as a, aesEncrypt as b, defaultSignature as c, defaultZipFile as d, aesDecrypt as e, defaultVerify as f, hashBuffer as h };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "electron-incremental-update",
   "type": "module",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.4",
   "description": "electron incremental update tools, powered by vite",
   "author": "subframe7536",
   "license": "MIT",
@@ -52,17 +52,17 @@
     "registry": "https://registry.npmjs.org/"
   },
   "peerDependencies": {
-    "@babel/core": "^7.24.7",
-    "@babel/plugin-transform-arrow-functions": "^7.24.7",
     "@electron/asar": "*",
     "esbuild": "*",
-    "magic-string": "*",
-    "vite-plugin-electron": "^0.15.6 || ^0.28"
+    "magic-string": "*"
   },
   "dependencies": {
+    "@babel/core": "^7.24.7",
+    "@babel/plugin-transform-arrow-functions": "^7.24.7",
     "@subframe7536/type-utils": "^0.1.6",
     "local-pkg": "^0.5.0",
-    "selfsigned": "^2.4.1"
+    "selfsigned": "^2.4.1",
+    "vite-plugin-electron": "^0.28.7"
   },
   "devDependencies": {
     "@subframe7536/eslint-config": "^0.7.2",
@@ -78,4 +78,4 @@
     "vite-plugin-electron": "^0.28.7",
     "vitest": "^2.0.3"
   }
-}
+}