electron-incremental-update 0.9.1 → 1.0.0

package/dist/vite.js

@@ -30,14 +30,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/vite.ts
 var vite_exports = {};
 __export(vite_exports, {
-  ElectronUpdater: () => ElectronUpdater
+  debugStartup: () => debugStartup,
+  electronWithUpdater: () => electronWithUpdater
 });
 module.exports = __toCommonJS(vite_exports);
+var import_node_path3 = require("path");
+var import_node_fs4 = require("fs");
 var import_vite = require("vite");
+var import_simple = __toESM(require("vite-plugin-electron/simple"));
+var import_vite_plugin_electron = require("vite-plugin-electron");
+var import_plugin = require("vite-plugin-electron/plugin");
 
 // src/build-plugins/build.ts
 var import_promises = require("fs/promises");
 var import_node_fs2 = require("fs");
+var import_node_path = require("path");
 var import_asar = __toESM(require("@electron/asar"));
 var import_esbuild = require("esbuild");
 
@@ -58,26 +65,7 @@ var signature = (buffer, privateKey, cert, version) => {
   return encrypt(`${sig}%${version}`, key(cert, 32), key(buffer, 16));
 };
 
-// src/utils/zip.ts
-var import_node_fs = require("fs");
-var import_node_zlib = require("zlib");
-async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
-  if (!(0, import_node_fs.existsSync)(filePath)) {
-    throw new Error(`path to be zipped not exist: ${filePath}`);
-  }
-  const buffer = (0, import_node_fs.readFileSync)(filePath);
-  return new Promise((resolve, reject) => {
-    (0, import_node_zlib.gzip)(buffer, (err, buffer2) => {
-      if (err) {
-        reject(err);
-      }
-      (0, import_node_fs.writeFileSync)(targetFilePath, buffer2);
-      resolve(null);
-    });
-  });
-}
-
-// src/utils/version.ts
+// src/utils/noDep.ts
 function parseVersion(version) {
   const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
   const match = semver.exec(version);
@@ -102,11 +90,28 @@ function parseVersion(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);
+  const is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  return is(json) && is(json?.beta);
+}
+
+// src/utils/zip.ts
+var import_node_fs = require("fs");
+var import_node_zlib = require("zlib");
+async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
+  if (!(0, import_node_fs.existsSync)(filePath)) {
+    throw new Error(`path to be zipped not exist: ${filePath}`);
+  }
+  const buffer = (0, import_node_fs.readFileSync)(filePath);
+  return new Promise((resolve2, reject) => {
+    (0, import_node_zlib.gzip)(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      }
+      (0, import_node_fs.writeFileSync)(targetFilePath, buffer2);
+      resolve2(null);
+    });
+  });
 }
 
 // src/build-plugins/build.ts
@@ -117,8 +122,8 @@ async function buildAsar({
   electronDistPath,
   rendererDistPath
 }) {
-  await (0, import_promises.rename)(rendererDistPath, `${electronDistPath}/renderer`);
-  await (0, import_promises.writeFile)(`${electronDistPath}/version`, version);
+  await (0, import_promises.rename)(rendererDistPath, (0, import_node_path.join)(electronDistPath, "renderer"));
+  await (0, import_promises.writeFile)((0, import_node_path.join)(electronDistPath, "version"), version);
   await import_asar.default.createPackage(electronDistPath, asarOutputPath);
   await zipFile(asarOutputPath, gzipPath);
 }
@@ -146,13 +151,15 @@ async function buildVersion({
   };
   if ((0, import_node_fs2.existsSync)(versionPath)) {
     try {
-      _json = JSON.parse(await (0, import_promises.readFile)(versionPath, "utf-8"));
+      const oldVersionJson = JSON.parse(await (0, import_promises.readFile)(versionPath, "utf-8"));
+      if (isUpdateJSON(oldVersionJson)) {
+        _json = oldVersionJson;
+      } else {
+        console.warn("old version json is invalid, ignore it");
+      }
     } catch (error) {
     }
   }
-  if (!isUpdateJSON(_json)) {
-    throw new Error("invalid version file");
-  }
   const buffer = await (0, import_promises.readFile)(gzipPath);
   const sig = await (generateSignature ?? signature)(buffer, privateKey, cert, version);
   if (generateVersionJson) {
@@ -161,10 +168,12 @@ async function buildVersion({
       throw new Error("invalid version info");
     }
   } else {
-    _json.beta.version = version;
-    _json.beta.minimumVersion = minimumVersion;
-    _json.beta.signature = sig;
-    _json.beta.size = buffer.length;
+    _json.beta = {
+      version,
+      minimumVersion,
+      signature: sig,
+      size: buffer.length
+    };
     if (!parseVersion(version).stage) {
       _json.version = version;
       _json.minimumVersion = minimumVersion;
@@ -175,30 +184,57 @@ async function buildVersion({
   await (0, import_promises.writeFile)(versionPath, JSON.stringify(_json, null, 2));
 }
 async function buildEntry({
-  entryPath,
-  entryOutputPath: outfile,
-  minify
+  sourcemap,
+  minify,
+  appEntryPath,
+  entryOutputDirPath,
+  nativeModuleEntryMap,
+  overrideEsbuildOptions,
+  postBuild
 }) {
   await (0, import_esbuild.build)({
-    entryPoints: [entryPath],
+    entryPoints: {
+      entry: appEntryPath,
+      ...nativeModuleEntryMap
+    },
     bundle: true,
     platform: "node",
-    outfile,
+    outdir: entryOutputDirPath,
     minify,
-    external: ["electron", "original-fs"]
+    sourcemap,
+    entryNames: "[dir]/[name]",
+    assetNames: "[dir]/[name]",
+    external: ["electron", "original-fs"],
+    loader: {
+      ".node": "empty"
+    },
+    ...overrideEsbuildOptions
+  });
+  await postBuild?.({
+    getPathFromEntryOutputDir(...paths) {
+      return (0, import_node_path.join)(entryOutputDirPath, ...paths);
+    },
+    existsAndCopyToEntryOutputDir({ from, to, skipIfExist = true }) {
+      if ((0, import_node_fs2.existsSync)(from)) {
+        const target = (0, import_node_path.join)(entryOutputDirPath, to ?? (0, import_node_path.basename)(from));
+        if (!skipIfExist || !(0, import_node_fs2.existsSync)(target)) {
+          (0, import_node_fs2.cpSync)(from, target);
+        }
+      }
+    }
   });
 }
 
 // src/build-plugins/key.ts
 var import_node_fs3 = require("fs");
-var import_node_path = require("path");
+var import_node_path2 = require("path");
 var import_selfsigned = require("selfsigned");
 function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
-  const privateKeyDir = (0, import_node_path.dirname)(privateKeyPath);
+  const privateKeyDir = (0, import_node_path2.dirname)(privateKeyPath);
   if (!(0, import_node_fs3.existsSync)(privateKeyDir)) {
     (0, import_node_fs3.mkdirSync)(privateKeyDir, { recursive: true });
   }
-  const certDir = (0, import_node_path.dirname)(certPath);
+  const certDir = (0, import_node_path2.dirname)(certPath);
   if (!(0, import_node_fs3.existsSync)(certDir)) {
     (0, import_node_fs3.mkdirSync)(certDir, { recursive: true });
   }
@@ -210,31 +246,21 @@ function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
   (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) {
+var noCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)['"]{2}/m;
+var existCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)(['"]-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\\n['"])/m;
+function writeCertToEntry(entryPath, cert) {
+  if (!(0, import_node_fs3.existsSync)(entryPath)) {
+    throw new Error(`entry not exist: ${entryPath}`);
+  }
   const file = (0, import_node_fs3.readFileSync)(entryPath, "utf-8");
-  const initRegex = /(?<=const SIGNATURE_CERT\s*=\s*)['"]{2}/m;
-  const existRegex = /(?<=const SIGNATURE_CERT\s*=\s*)(['"]-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\\n['"])/m;
-  const eol = file.includes("\r") ? "\r\n" : "\n";
-  const replacement = cert.split("\n").filter(Boolean).map((s) => `'${s}\\n'`).join(`${eol}  + `);
+  const replacement = cert.split("\n").filter(Boolean).map((s) => `'${s}\\n'`).join("\n  + ");
   let replaced = file;
-  if (initRegex.test(file)) {
-    replaced = file.replace(initRegex, replacement);
-  } else if (existRegex.test(file)) {
-    replaced = file.replace(existRegex, replacement);
+  if (noCertRegex.test(file)) {
+    replaced = file.replace(noCertRegex, replacement);
+  } else if (existCertRegex.test(file)) {
+    replaced = file.replace(existCertRegex, replacement);
   } else {
-    const lines = file.split(eol);
-    const r = `${eol}const SIGNATURE_CERT = ${replacement}${eol}`;
-    let isMatched = false;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (!line.startsWith("import") && !line.startsWith("/")) {
-        lines.splice(i, 0, r);
-        isMatched = true;
-        break;
-      }
-    }
-    !isMatched && lines.push(r);
-    replaced = lines.join(eol);
+    throw new Error("no `SIGNATURE_CERT` found in entry");
   }
   (0, import_node_fs3.writeFileSync)(entryPath, replaced);
 }
@@ -242,45 +268,40 @@ function parseKeys({
   keyLength,
   privateKeyPath,
   certPath,
-  entryPath,
+  appEntryPath,
   subject,
   days
 }) {
-  const keysDir = (0, import_node_path.dirname)(privateKeyPath);
+  const keysDir = (0, import_node_path2.dirname)(privateKeyPath);
   !(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)) {
+    console.warn("no key pair found, generate new key pair");
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
   const privateKey = process.env.UPDATER_PK || (0, import_node_fs3.readFileSync)(privateKeyPath, "utf-8");
   const cert = process.env.UPDATER_CERT || (0, import_node_fs3.readFileSync)(certPath, "utf-8");
-  writeCertToMain(entryPath, cert);
-  return {
-    privateKey,
-    cert
-  };
+  writeCertToEntry(appEntryPath, cert);
+  return { privateKey, cert };
 }
 function parseSubjects(subject) {
-  const ret = [];
-  Object.keys(subject).forEach((name) => {
-    const value = subject[name];
-    value && ret.push({ name, value });
-  });
-  return ret;
+  return Object.entries(subject).filter(([_, value]) => !!value).map(([name, value]) => ({ name, value }));
 }
 
 // src/build-plugins/option.ts
-function parseOptions(options) {
+function parseOptions(isBuild, pkg, options = {}) {
   const {
-    isBuild,
-    productName,
-    version,
-    minimumVersion = version,
-    minify = false,
+    minimumVersion = "0.0.0",
+    entry: {
+      minify = isBuild,
+      sourcemap = isBuild,
+      entryOutputDirPath = "dist-entry",
+      appEntryPath = "electron/entry.ts",
+      nativeModuleEntryMap = {},
+      postBuild
+    } = {},
     paths: {
-      entryPath = "electron/app.ts",
-      entryOutputPath = "app.js",
-      asarOutputPath = `release/${productName}.asar`,
-      gzipPath = `release/${productName}-${version}.asar.gz`,
+      asarOutputPath = `release/${pkg.name}.asar`,
+      gzipPath = `release/${pkg.name}-${pkg.version}.asar.gz`,
       electronDistPath = "dist-electron",
       rendererDistPath = "dist",
       versionPath = "version.json"
@@ -290,39 +311,42 @@ function parseOptions(options) {
       certPath = "keys/cert.pem",
       keyLength = 2048,
       certInfo = {},
-      overrideFunctions = {}
+      overrideGenerator = {}
     } = {}
   } = options;
-  const { generateSignature, generateVersionJson } = overrideFunctions;
+  const { generateSignature, generateVersionJson } = overrideGenerator;
   let {
     subject = {
-      commonName: productName,
-      organizationName: `org.${productName}`
+      commonName: pkg.name,
+      organizationName: `org.${pkg.name}`
     },
-    days = 365
+    days = 3650
   } = certInfo;
   const buildAsarOption = {
-    version,
+    version: pkg.version,
     asarOutputPath,
     gzipPath,
     electronDistPath,
     rendererDistPath
   };
   const buildEntryOption = {
-    entryPath,
-    entryOutputPath,
-    minify
+    minify,
+    sourcemap,
+    entryOutputDirPath,
+    appEntryPath,
+    nativeModuleEntryMap,
+    postBuild
   };
   const { privateKey, cert } = parseKeys({
     keyLength,
     privateKeyPath,
     certPath,
-    entryPath,
+    appEntryPath,
     subject,
     days
   });
   const buildVersionOption = {
-    version,
+    version: pkg.version,
     minimumVersion,
     gzipPath,
     privateKey,
@@ -331,34 +355,131 @@ function parseOptions(options) {
     generateSignature,
     generateVersionJson
   };
-  return { isBuild, buildAsarOption, buildEntryOption, buildVersionOption };
+  return { buildAsarOption, buildEntryOption, buildVersionOption };
 }
 
 // src/vite.ts
-function ElectronUpdater(options) {
-  const { isBuild, buildAsarOption, buildEntryOption, buildVersionOption } = parseOptions(options);
-  const { entryPath, entryOutputPath } = buildEntryOption;
-  const { asarOutputPath } = buildAsarOption;
-  const id = "electron-incremental-updater";
-  const log = (0, import_vite.createLogger)("info", { prefix: `[${id}]` });
-  return {
-    name: `vite-plugin-${id}`,
-    enforce: "post",
-    async closeBundle() {
-      log.info("build entry start", { timestamp: true });
-      await buildEntry(buildEntryOption);
-      log.info(`build entry end, ${entryPath} -> ${entryOutputPath}`, { timestamp: true });
-      if (!isBuild) {
-        return;
-      }
-      log.info("build asar start", { timestamp: true });
-      await buildAsar(buildAsarOption);
-      await buildVersion(buildVersionOption);
-      log.info(`build asar end, output to ${asarOutputPath}`, { timestamp: true });
+function debugStartup(args) {
+  process.env.VSCODE_DEBUG ? console.log("[startup] Electron App") : args.startup();
+}
+var id = "electron-incremental-updater";
+var log = (0, import_vite.createLogger)("info", { prefix: `[${id}]` });
+function electronWithUpdater(options) {
+  const {
+    isBuild,
+    pkg,
+    main: _main,
+    preload: _preload,
+    updater,
+    useNotBundle = true,
+    logParsedOptions
+  } = options;
+  const _options = parseOptions(isBuild, pkg, updater);
+  try {
+    (0, import_node_fs4.rmSync)(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
+    (0, import_node_fs4.rmSync)(_options.buildEntryOption.entryOutputDirPath, { recursive: true, force: true });
+  } catch (ignore) {
+  }
+  log.info(`remove old files`, { timestamp: true });
+  const { buildAsarOption, buildEntryOption, buildVersionOption } = _options;
+  const { entryOutputDirPath, nativeModuleEntryMap, appEntryPath } = buildEntryOption;
+  const sourcemap = isBuild || !!process.env.VSCODE_DEBUG;
+  const _appPath = (0, import_node_path3.join)(entryOutputDirPath, "entry.js");
+  if ((0, import_node_path3.resolve)((0, import_vite.normalizePath)(pkg.main)) !== (0, import_node_path3.resolve)((0, import_vite.normalizePath)(_appPath))) {
+    throw new Error(`wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath.replace(/\\/g, "/")}"`);
+  }
+  let isInit = false;
+  const _buildEntry = async () => {
+    await buildEntry(buildEntryOption);
+    log.info(`build entry to '${entryOutputDirPath}'`, { timestamp: true });
+  };
+  const electronPluginOptions = {
+    main: {
+      entry: _main.files,
+      onstart: async (args) => {
+        if (!isInit) {
+          isInit = true;
+          await _buildEntry();
+        }
+        _main.onstart?.(args) ?? args.startup();
+      },
+      vite: (0, import_vite.mergeConfig)(
+        {
+          plugins: !isBuild && useNotBundle ? [(0, import_plugin.notBundle)()] : void 0,
+          build: {
+            sourcemap,
+            minify: isBuild,
+            outDir: `${buildAsarOption.electronDistPath}/main`,
+            rollupOptions: {
+              external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
+            }
+          }
+        },
+        _main.vite ?? {}
+      )
+    },
+    preload: {
+      input: _preload.files,
+      onstart: _preload.onstart,
+      vite: (0, import_vite.mergeConfig)(
+        {
+          plugins: [
+            {
+              name: `${id}-build`,
+              enforce: "post",
+              apply() {
+                return isBuild;
+              },
+              async closeBundle() {
+                await _buildEntry();
+                await buildAsar(buildAsarOption);
+                log.info(`build asar to '${buildAsarOption.asarOutputPath}'`, { timestamp: true });
+                await buildVersion(buildVersionOption);
+                log.info(`build version info to '${buildVersionOption.versionPath}'`, { timestamp: true });
+              }
+            }
+          ],
+          build: {
+            sourcemap: sourcemap ? "inline" : void 0,
+            minify: isBuild,
+            outDir: `${buildAsarOption.electronDistPath}/preload`,
+            rollupOptions: {
+              external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
+            }
+          }
+        },
+        _preload.vite ?? {}
+      )
     }
   };
+  logParsedOptions && log.info(
+    JSON.stringify(
+      {
+        ...electronPluginOptions,
+        updater: { buildAsarOption, buildEntryOption, buildVersionOption }
+      },
+      (key2, value) => key2 === "privateKey" || key2 === "cert" ? "***" : value,
+      2
+    ),
+    { timestamp: true }
+  );
+  let extraHmrPlugin;
+  if (nativeModuleEntryMap) {
+    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => (0, import_node_path3.resolve)((0, import_vite.normalizePath)(file)));
+    extraHmrPlugin = {
+      name: `${id}-dev`,
+      apply() {
+        return !isBuild;
+      },
+      configureServer: (server) => {
+        server.watcher.add(files).on("change", (p) => files.includes(p) && _buildEntry().then(() => (0, import_vite_plugin_electron.startup)()));
+      }
+    };
+  }
+  return [(0, import_simple.default)(electronPluginOptions), extraHmrPlugin];
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ElectronUpdater
+  debugStartup,
+  electronWithUpdater
 });