electron-incremental-update 1.0.3 → 1.1.0

package/dist/{chunk-OUZLSVQC.mjs → chunk-CXHA5TF7.js}

@@ -1,6 +1,9 @@
-import {
-  __require
-} from "./chunk-GB6VLKJZ.mjs";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/utils/electron.ts
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
@@ -133,7 +136,86 @@ function getPaths(entryDirName = "dist-entry") {
   };
 }
 
+// src/utils/zip.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
+import { gunzip, gzip } from "node:zlib";
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
+  if (!existsSync2(gzipPath)) {
+    throw new Error(`path to zipped file not exist: ${gzipPath}`);
+  }
+  const compressedBuffer = readFileSync2(gzipPath);
+  return new Promise((resolve, reject) => {
+    gunzip(compressedBuffer, (err, buffer) => {
+      rmSync(gzipPath);
+      if (err) {
+        reject(err);
+      }
+      writeFileSync(targetFilePath, buffer);
+      resolve(null);
+    });
+  });
+}
+async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
+  if (!existsSync2(filePath)) {
+    throw new Error(`path to be zipped not exist: ${filePath}`);
+  }
+  const buffer = readFileSync2(filePath);
+  return new Promise((resolve, reject) => {
+    gzip(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      }
+      writeFileSync(targetFilePath, buffer2);
+      resolve(null);
+    });
+  });
+}
+
+// src/utils/pure.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);
+}
+function parseVersion(version) {
+  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-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 (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return ret;
+}
+function isUpdateJSON(json) {
+  const is2 = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  return is2(json) && is2(json?.beta);
+}
+
 export {
+  __require,
   is,
   getPathFromAppNameAsar,
   getVersions,
@@ -144,5 +226,11 @@ export {
   singleInstance,
   setPortableAppDataPath,
   waitAppReady,
-  getPaths
+  getPaths,
+  unzipFile,
+  zipFile,
+  parseGithubCdnURL,
+  handleUnexpectedErrors,
+  parseVersion,
+  isUpdateJSON
 };

package/dist/{index.mjs → index.cjs}

@@ -1,29 +1,162 @@
-import {
-  verify
-} from "./chunk-GXZSAUBR.mjs";
-import {
-  getPathFromAppNameAsar,
-  getVersions,
-  is,
-  restartApp,
-  waitAppReady
-} from "./chunk-OUZLSVQC.mjs";
-import {
-  __require,
-  isUpdateJSON,
-  parseVersion,
-  unzipFile
-} from "./chunk-GB6VLKJZ.mjs";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-import { resolve } from "node:path";
-import { existsSync as existsSync2, renameSync } from "node:fs";
-import { app as app2 } from "electron";
+var src_exports = {};
+__export(src_exports, {
+  DownloadError: () => DownloadError,
+  MinimumVersionError: () => MinimumVersionError,
+  Updater: () => Updater,
+  VerifyFailedError: () => VerifyFailedError,
+  createUpdater: () => createUpdater,
+  initApp: () => initApp,
+  startupWithUpdater: () => startupWithUpdater
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_path2 = require("path");
+var import_node_fs4 = require("fs");
+var import_electron4 = require("electron");
 
 // src/updater/core.ts
-import { existsSync } from "node:fs";
-import { rm, writeFile } from "node:fs/promises";
-import { app } from "electron";
+var import_node_fs3 = require("fs");
+var import_promises = require("fs/promises");
+var import_electron3 = require("electron");
+
+// src/utils/electron.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os = require("os");
+var import_electron = require("electron");
+var is = {
+  dev: !import_electron.app.isPackaged,
+  win: process.platform === "win32",
+  mac: process.platform === "darwin",
+  linux: process.platform === "linux"
+};
+function getPathFromAppNameAsar(...path) {
+  return is.dev ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${import_electron.app.name}.asar`, ...path);
+}
+function getVersions() {
+  const platform = is.win ? "Windows" : is.mac ? "MacOS" : process.platform.toUpperCase();
+  return {
+    appVersion: is.dev ? import_electron.app.getVersion() : (0, import_node_fs.readFileSync)(getPathFromAppNameAsar("version"), "utf-8"),
+    entryVersion: import_electron.app.getVersion(),
+    electronVersion: process.versions.electron,
+    nodeVersion: process.versions.node,
+    systemVersion: `${platform} ${(0, import_node_os.release)()}`
+  };
+}
+function restartApp() {
+  import_electron.app.relaunch();
+  import_electron.app.quit();
+}
+function waitAppReady(timeout = 1e3) {
+  return import_electron.app.isReady() ? Promise.resolve() : new Promise((resolve2, reject) => {
+    const _ = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, timeout);
+    import_electron.app.whenReady().then(() => {
+      clearTimeout(_);
+      resolve2();
+    });
+  });
+}
+
+// src/utils/zip.ts
+var import_node_fs2 = require("fs");
+var import_node_zlib = require("zlib");
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
+  if (!(0, import_node_fs2.existsSync)(gzipPath)) {
+    throw new Error(`path to zipped file not exist: ${gzipPath}`);
+  }
+  const compressedBuffer = (0, import_node_fs2.readFileSync)(gzipPath);
+  return new Promise((resolve2, reject) => {
+    (0, import_node_zlib.gunzip)(compressedBuffer, (err, buffer) => {
+      (0, import_node_fs2.rmSync)(gzipPath);
+      if (err) {
+        reject(err);
+      }
+      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer);
+      resolve2(null);
+    });
+  });
+}
+
+// src/utils/pure.ts
+function parseVersion(version) {
+  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-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 (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return ret;
+}
+function isUpdateJSON(json) {
+  const is2 = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  return is2(json) && is2(json?.beta);
+}
+
+// src/crypto/dec.ts
+var import_node_crypto2 = require("crypto");
+
+// src/crypto/utils.ts
+var import_node_crypto = require("crypto");
+function hashString(data, length) {
+  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
+
+// src/crypto/dec.ts
+function decrypt(encryptedText, key, iv) {
+  const decipher = (0, import_node_crypto2.createDecipheriv)("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(encryptedText, "base64url", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+var verify = (buffer, signature, cert) => {
+  try {
+    const [sig, version] = decrypt(signature, hashString(cert, 32), hashString(buffer, 16)).split("%");
+    const result = (0, import_node_crypto2.createVerify)("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return result ? version : false;
+  } catch (error) {
+    return false;
+  }
+};
+
+// src/crypto/enc.ts
+var import_node_crypto3 = require("crypto");
 
 // src/updater/types.ts
 var MinimumVersionError = class extends Error {
@@ -51,11 +184,11 @@ var DownloadError = class extends Error {
 };
 
 // src/updater/defaultFunctions/download.ts
-import { net } from "electron";
+var import_electron2 = require("electron");
 var downloadJSONDefault = async (url, headers) => {
   await waitAppReady();
   return new Promise((resolve2, reject) => {
-    const request = net.request({
+    const request = import_electron2.net.request({
       url,
       method: "GET",
       redirect: "follow"
@@ -89,7 +222,7 @@ var downloadBufferDefault = async (url, headers, total, onDownloading) => {
   await waitAppReady();
   let current = 0;
   return new Promise((resolve2, reject) => {
-    const request = net.request({
+    const request = import_electron2.net.request({
       url,
       method: "GET",
       redirect: "follow"
@@ -189,13 +322,13 @@ var Updater = class {
     return await compare(appVersion, version);
   }
   async parseData(format, data) {
-    if (existsSync(this.tmpFilePath)) {
+    if ((0, import_node_fs3.existsSync)(this.tmpFilePath)) {
       this.logger?.warn(`remove tmp file: ${this.tmpFilePath}`);
-      await rm(this.tmpFilePath);
+      await (0, import_promises.rm)(this.tmpFilePath);
     }
-    if (existsSync(this.gzipPath)) {
+    if ((0, import_node_fs3.existsSync)(this.gzipPath)) {
       this.logger?.warn(`remove .gz file: ${this.gzipPath}`);
-      await rm(this.gzipPath);
+      await (0, import_promises.rm)(this.gzipPath);
     }
     if (!["string", "object", "undefined"].includes(typeof data)) {
       throw new TypeError(`invalid type at format '${format}': ${data}`);
@@ -221,7 +354,7 @@ var Updater = class {
     } : {
       name: "releaseAsarURL",
       url: this.option.releaseAsarURL,
-      repoFallback: `${this.option.repository}/releases/download/v${this.info?.version}/${app.name}-${this.info?.version}.asar.gz`,
+      repoFallback: `${this.option.repository}/releases/download/v${this.info?.version}/${import_electron3.app.name}-${this.info?.version}.asar.gz`,
       fn: this.option.overrideFunctions?.downloadBuffer ?? downloadBufferDefault
     };
     data ??= config.url;
@@ -307,7 +440,7 @@ var Updater = class {
       }
       this.logger?.info("verify success");
       this.logger?.info(`write to ${this.gzipPath}`);
-      await writeFile(this.gzipPath, buffer);
+      await (0, import_promises.writeFile)(this.gzipPath, buffer);
       this.logger?.info(`extract to ${this.tmpFilePath}`);
       await unzipFile(this.gzipPath, this.tmpFilePath);
       this.logger?.info(`download success, version: ${_ver}`);
@@ -354,21 +487,21 @@ function initApp(appOptions) {
   function handleError(err, logger) {
     console.error(err);
     onStartError?.(err, logger);
-    app2.quit();
+    import_electron4.app.quit();
   }
   async function startup(updater) {
     const logger = updater.logger;
     try {
       const appNameAsarPath = getPathFromAppNameAsar();
       const tempAsarPath = `${appNameAsarPath}.tmp`;
-      if (existsSync2(tempAsarPath)) {
+      if ((0, import_node_fs4.existsSync)(tempAsarPath)) {
         logger?.info(`installing new asar: ${tempAsarPath}`);
-        await onInstall(() => renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
+        await onInstall(() => (0, import_node_fs4.renameSync)(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
       }
       const mainDir = is.dev ? electronDevDistPath : appNameAsarPath;
-      const entry = resolve(__dirname, mainDir, mainPath);
+      const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
       await beforeStart?.(entry, logger);
-      __require(entry)(updater);
+      require(entry)(updater);
     } catch (error) {
       handleError(error, logger);
     }
@@ -389,7 +522,8 @@ function initApp(appOptions) {
     }
   };
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   DownloadError,
   MinimumVersionError,
   Updater,
@@ -397,4 +531,4 @@ export {
   createUpdater,
   initApp,
   startupWithUpdater
-};
+});

package/dist/{index.d.mts → index.d.cts}

@@ -1,4 +1,4 @@
-import { U as UpdateInfo, a as UpdateJSON } from './noDep-TvZoKVF8.mjs';
+import { U as UpdateInfo, a as UpdateJSON } from './pure-GoN_3MEj.cjs';
 
 declare class MinimumVersionError extends Error {
     currentVersion: string;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { U as UpdateInfo, a as UpdateJSON } from './noDep-TvZoKVF8.js';
+import { U as UpdateInfo, a as UpdateJSON } from './pure-GoN_3MEj.js';
 
 declare class MinimumVersionError extends Error {
     currentVersion: string;