electron-incremental-update 0.9.1 → 1.0.0

package/dist/vite.mjs

@@ -1,18 +1,24 @@
 import {
-  isUpdateJSON,
   signature
-} from "./chunk-5BZLJPHJ.mjs";
+} from "./chunk-GXZSAUBR.mjs";
 import {
+  isUpdateJSON,
   parseVersion,
   zipFile
-} from "./chunk-CMBFI77K.mjs";
+} from "./chunk-GB6VLKJZ.mjs";
 
 // src/vite.ts
-import { createLogger } from "vite";
+import { join as join2, resolve } from "node:path";
+import { rmSync } from "node:fs";
+import { createLogger, mergeConfig, normalizePath } from "vite";
+import ElectronSimple from "vite-plugin-electron/simple";
+import { startup } from "vite-plugin-electron";
+import { notBundle } from "vite-plugin-electron/plugin";
 
 // src/build-plugins/build.ts
 import { readFile, rename, writeFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
+import { cpSync, existsSync } from "node:fs";
+import { basename, join } from "node:path";
 import Asar from "@electron/asar";
 import { build } from "esbuild";
 async function buildAsar({
@@ -22,8 +28,8 @@ async function buildAsar({
   electronDistPath,
   rendererDistPath
 }) {
-  await rename(rendererDistPath, `${electronDistPath}/renderer`);
-  await writeFile(`${electronDistPath}/version`, version);
+  await rename(rendererDistPath, join(electronDistPath, "renderer"));
+  await writeFile(join(electronDistPath, "version"), version);
   await Asar.createPackage(electronDistPath, asarOutputPath);
   await zipFile(asarOutputPath, gzipPath);
 }
@@ -51,13 +57,15 @@ async function buildVersion({
   };
   if (existsSync(versionPath)) {
     try {
-      _json = JSON.parse(await readFile(versionPath, "utf-8"));
+      const oldVersionJson = JSON.parse(await 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 readFile(gzipPath);
   const sig = await (generateSignature ?? signature)(buffer, privateKey, cert, version);
   if (generateVersionJson) {
@@ -66,10 +74,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;
@@ -80,17 +90,44 @@ async function buildVersion({
   await writeFile(versionPath, JSON.stringify(_json, null, 2));
 }
 async function buildEntry({
-  entryPath,
-  entryOutputPath: outfile,
-  minify
+  sourcemap,
+  minify,
+  appEntryPath,
+  entryOutputDirPath,
+  nativeModuleEntryMap,
+  overrideEsbuildOptions,
+  postBuild
 }) {
   await 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 join(entryOutputDirPath, ...paths);
+    },
+    existsAndCopyToEntryOutputDir({ from, to, skipIfExist = true }) {
+      if (existsSync(from)) {
+        const target = join(entryOutputDirPath, to ?? basename(from));
+        if (!skipIfExist || !existsSync(target)) {
+          cpSync(from, target);
+        }
+      }
+    }
   });
 }
 
@@ -115,31 +152,21 @@ function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
   writeFileSync(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
   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 (!existsSync2(entryPath)) {
+    throw new Error(`entry not exist: ${entryPath}`);
+  }
   const file = 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");
   }
   writeFileSync(entryPath, replaced);
 }
@@ -147,45 +174,40 @@ function parseKeys({
   keyLength,
   privateKeyPath,
   certPath,
-  entryPath,
+  appEntryPath,
   subject,
   days
 }) {
   const keysDir = dirname(privateKeyPath);
   !existsSync2(keysDir) && mkdirSync(keysDir);
   if (!existsSync2(privateKeyPath) || !existsSync2(certPath)) {
+    console.warn("no key pair found, generate new key pair");
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
   const privateKey = process.env.UPDATER_PK || readFileSync(privateKeyPath, "utf-8");
   const cert = process.env.UPDATER_CERT || 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"
@@ -195,39 +217,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,
@@ -236,33 +261,130 @@ 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 = 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 = 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 {
+    rmSync(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
+    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 = join2(entryOutputDirPath, "entry.js");
+  if (resolve(normalizePath(pkg.main)) !== resolve(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: mergeConfig(
+        {
+          plugins: !isBuild && useNotBundle ? [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: 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 }
+      },
+      (key, value) => key === "privateKey" || key === "cert" ? "***" : value,
+      2
+    ),
+    { timestamp: true }
+  );
+  let extraHmrPlugin;
+  if (nativeModuleEntryMap) {
+    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => resolve(normalizePath(file)));
+    extraHmrPlugin = {
+      name: `${id}-dev`,
+      apply() {
+        return !isBuild;
+      },
+      configureServer: (server) => {
+        server.watcher.add(files).on("change", (p) => files.includes(p) && _buildEntry().then(() => startup()));
+      }
+    };
+  }
+  return [ElectronSimple(electronPluginOptions), extraHmrPlugin];
 }
 export {
-  ElectronUpdater
+  debugStartup,
+  electronWithUpdater
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-incremental-update",
-  "version": "0.9.1",
+  "version": "1.0.0",
   "description": "electron incremental update tools, powered by vite",
   "author": "subframe7536",
   "license": "MIT",
@@ -45,22 +45,29 @@
     "registry": "https://registry.npmjs.org/"
   },
   "peerDependencies": {
-    "esbuild": "*"
+    "esbuild": "*",
+    "vite-plugin-electron": "^0.15.6 || ^0.28"
   },
   "dependencies": {
     "@electron/asar": "^3.2.8",
-    "ci-info": "^4.0.0",
+    "@subframe7536/type-utils": "^0.1.4",
     "selfsigned": "^2.4.1"
   },
   "devDependencies": {
-    "@subframe7536/eslint-config": "^0.5.2",
-    "@types/node": "^20.10.1",
-    "bumpp": "^9.2.0",
-    "electron": "^27.1.2",
-    "eslint": "^8.54.0",
+    "@subframe7536/eslint-config": "^0.5.9",
+    "@types/node": "^20.11.5",
+    "bumpp": "^9.3.0",
+    "electron": "28.1.1",
+    "eslint": "^8.56.0",
     "tsup": "^8.0.1",
-    "typescript": "^5.3.2",
-    "vite": "^5.0.4",
-    "vitest": "^0.34.6"
+    "typescript": "^5.3.3",
+    "vite": "^5.0.12",
+    "vite-plugin-electron": "^0.15.6",
+    "vitest": "^1.2.1"
+  },
+  "pnpm": {
+    "overrides": {
+      "has": "npm:@nolyfill/has@latest"
+    }
   }
 }

package/dist/chunk-SPZL37O5.mjs

@@ -1,124 +0,0 @@
-import {
-  __require
-} from "./chunk-CMBFI77K.mjs";
-
-// src/utils/core.ts
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { release } from "node:os";
-import { app } from "electron";
-var DEFAULT_APP_NAME = "product";
-var is = {
-  dev: !app.isPackaged,
-  win: process.platform === "win32",
-  mac: process.platform === "darwin",
-  linux: process.platform === "linux"
-};
-function getLocale() {
-  return app.isReady() ? app.getLocale() : void 0;
-}
-function getProductAsarPath(name = DEFAULT_APP_NAME) {
-  return !app.isPackaged ? join(dirname(app.getAppPath()), `${name}.asar`) : "DEV.asar";
-}
-function getElectronVersion() {
-  return app.getVersion();
-}
-function getAppVersion(name = DEFAULT_APP_NAME) {
-  return app.isPackaged ? readFileSync(join(getProductAsarPath(name), "version"), "utf-8") : getElectronVersion();
-}
-var NoSuchNativeModuleError = class extends Error {
-  moduleName;
-  constructor(moduleName) {
-    super(`no such native module: ${moduleName}`);
-    this.moduleName = moduleName;
-  }
-};
-function isNoSuchNativeModuleError(e) {
-  return e instanceof NoSuchNativeModuleError;
-}
-function requireNative(packageName) {
-  const path = app.isPackaged ? join(app.getAppPath(), "node_modules", packageName) : packageName;
-  try {
-    return __require(path);
-  } catch (error) {
-    return new NoSuchNativeModuleError(packageName);
-  }
-}
-function restartApp() {
-  app.relaunch();
-  app.quit();
-}
-function setAppUserModelId(id) {
-  is.win && app.setAppUserModelId(is.dev ? process.execPath : id);
-}
-function disableHWAccForWin7() {
-  if (release().startsWith("6.1")) {
-    app.disableHardwareAcceleration();
-  }
-}
-function singleInstance() {
-  if (!app.requestSingleInstanceLock()) {
-    app.quit();
-    process.exit(0);
-  }
-}
-function setPortableAppDataPath(dirName = "data", create) {
-  if (!is.win) {
-    return;
-  }
-  const portablePath = join(dirname(app.getPath("exe")), dirName);
-  let exists = existsSync(portablePath);
-  if (create && !exists) {
-    mkdirSync(portablePath);
-    exists = true;
-  }
-  if (exists) {
-    app.setPath("appData", portablePath);
-  }
-}
-function waitAppReady(timeout = 1e3) {
-  return app.isReady() ? Promise.resolve() : new Promise((resolve, reject) => {
-    const _ = setTimeout(() => {
-      reject(new Error("app is not ready"));
-    }, timeout);
-    app.whenReady().then(() => {
-      clearTimeout(_);
-      resolve();
-    });
-  });
-}
-
-// src/utils/utils.ts
-function parseGithubCdnURL(originRepoURL, cdnPrefix, relativeFilePath) {
-  if (!originRepoURL.startsWith("https://github.com/")) {
-    throw new Error("origin url must start with https://github.com/");
-  }
-  originRepoURL = originRepoURL.trim().replace(/\/?$/, "/").trim();
-  relativeFilePath = relativeFilePath.trim().replace(/^\/|\/?$/g, "").trim();
-  cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
-  return originRepoURL.replace("github.com", cdnPrefix) + relativeFilePath;
-}
-function handleUnexpectedErrors(callback) {
-  process.on("uncaughtException", callback);
-  process.on("unhandledRejection", callback);
-}
-
-export {
-  DEFAULT_APP_NAME,
-  is,
-  getLocale,
-  getProductAsarPath,
-  getElectronVersion,
-  getAppVersion,
-  NoSuchNativeModuleError,
-  isNoSuchNativeModuleError,
-  requireNative,
-  restartApp,
-  setAppUserModelId,
-  disableHWAccForWin7,
-  singleInstance,
-  setPortableAppDataPath,
-  waitAppReady,
-  parseGithubCdnURL,
-  handleUnexpectedErrors
-};

package/dist/updateJson-synsK-Pt.d.mts

@@ -1,11 +0,0 @@
-type UpdateInfo = {
-    signature: string;
-    minimumVersion: string;
-    version: string;
-    size: number;
-};
-type UpdateJSON = UpdateInfo & {
-    beta: UpdateInfo;
-};
-
-export type { UpdateJSON as U };

package/dist/updateJson-synsK-Pt.d.ts

@@ -1,11 +0,0 @@
-type UpdateInfo = {
-    signature: string;
-    minimumVersion: string;
-    version: string;
-    size: number;
-};
-type UpdateJSON = UpdateInfo & {
-    beta: UpdateInfo;
-};
-
-export type { UpdateJSON as U };