electron-incremental-update 0.9.0 → 1.0.0

package/dist/utils.js

@@ -20,93 +20,155 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
-  DEFAULT_APP_NAME: () => DEFAULT_APP_NAME,
-  NoSuchNativeModuleError: () => NoSuchNativeModuleError,
-  getAppVersion: () => getAppVersion,
-  getElectronVersion: () => getElectronVersion,
-  getLocale: () => getLocale,
-  getProductAsarPath: () => getProductAsarPath,
+  disableHWAccForWin7: () => disableHWAccForWin7,
+  getPathFromAppNameAsar: () => getPathFromAppNameAsar,
+  getPaths: () => getPaths,
+  getVersions: () => getVersions,
   handleUnexpectedErrors: () => handleUnexpectedErrors,
   is: () => is,
-  isNoSuchNativeModuleError: () => isNoSuchNativeModuleError,
+  isUpdateJSON: () => isUpdateJSON,
+  loadNativeModuleFromEntry: () => loadNativeModuleFromEntry,
   parseGithubCdnURL: () => parseGithubCdnURL,
   parseVersion: () => parseVersion,
-  requireNative: () => requireNative,
   restartApp: () => restartApp,
   setAppUserModelId: () => setAppUserModelId,
   setPortableAppDataPath: () => setPortableAppDataPath,
+  singleInstance: () => singleInstance,
   unzipFile: () => unzipFile,
   waitAppReady: () => waitAppReady,
   zipFile: () => zipFile
 });
 module.exports = __toCommonJS(utils_exports);
 
-// src/utils/core.ts
+// 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 DEFAULT_APP_NAME = "product";
 var is = {
   dev: !import_electron.app.isPackaged,
   win: process.platform === "win32",
   mac: process.platform === "darwin",
   linux: process.platform === "linux"
 };
-function getLocale() {
-  return import_electron.app.isReady() ? import_electron.app.getLocale() : void 0;
+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 getProductAsarPath(name = DEFAULT_APP_NAME) {
-  return !import_electron.app.isPackaged ? (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${name}.asar`) : "DEV.asar";
+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 getElectronVersion() {
-  return import_electron.app.getVersion();
+function loadNativeModuleFromEntry(devEntryDirPath = "../../dist-entry", entryDirPath = (0, import_node_path.join)(import_electron.app.getAppPath(), (0, import_node_path.basename)(devEntryDirPath))) {
+  const path = is.dev ? devEntryDirPath : entryDirPath;
+  return (moduleName) => {
+    try {
+      return require((0, import_node_path.join)(path, moduleName));
+    } catch (error) {
+      console.error("fail to load module", error);
+    }
+  };
 }
-function getAppVersion(name = DEFAULT_APP_NAME) {
-  return import_electron.app.isPackaged ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(getProductAsarPath(name), "version"), "utf-8") : getElectronVersion();
+function restartApp() {
+  import_electron.app.relaunch();
+  import_electron.app.quit();
 }
-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 = import_electron.app.isPackaged ? (0, import_node_path.join)(import_electron.app.getAppPath(), "node_modules", packageName) : packageName;
-  try {
-    return require(path);
-  } catch (error) {
-    return new NoSuchNativeModuleError(packageName);
+function setAppUserModelId(id) {
+  import_electron.app.setAppUserModelId(is.dev ? process.execPath : id ?? `org.${import_electron.app.name}`);
+}
+function disableHWAccForWin7() {
+  if ((0, import_node_os.release)().startsWith("6.1")) {
+    import_electron.app.disableHardwareAcceleration();
   }
 }
-
-// src/utils/version.ts
-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}`);
+function singleInstance(window) {
+  const result = import_electron.app.requestSingleInstanceLock();
+  result ? import_electron.app.on("second-instance", () => {
+    if (window) {
+      window.show();
+      if (window.isMinimized()) {
+        window.restore();
+      }
+      window.focus();
+    }
+  }) : import_electron.app.quit();
+  return result;
+}
+function setPortableAppDataPath(dirName = "data") {
+  const portablePath = (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getPath("exe")), dirName);
+  if (!(0, import_node_fs.existsSync)(portablePath)) {
+    (0, import_node_fs.mkdirSync)(portablePath);
   }
-  const [major, minor, patch] = match.slice(1, 4).map(Number);
-  const ret = {
-    major,
-    minor,
-    patch,
-    stage: "",
-    stageVersion: -1
+  import_electron.app.setPath("appData", portablePath);
+}
+function waitAppReady(timeout = 1e3) {
+  return import_electron.app.isReady() ? Promise.resolve() : new Promise((resolve, reject) => {
+    const _ = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, timeout);
+    import_electron.app.whenReady().then(() => {
+      clearTimeout(_);
+      resolve();
+    });
+  });
+}
+function getPaths(entryDirName = "dist-entry") {
+  const root = (0, import_node_path.join)(__dirname, "..");
+  const mainDirPath = (0, import_node_path.join)(root, "main");
+  const preloadDirPath = (0, import_node_path.join)(root, "preload");
+  const rendererDirPath = (0, import_node_path.join)(root, "renderer");
+  const devServerURL = process.env.VITE_DEV_SERVER_URL;
+  const indexHTMLPath = (0, import_node_path.join)(rendererDirPath, "index.html");
+  const publicDirPath = devServerURL ? (0, import_node_path.join)(root, "../public") : rendererDirPath;
+  return {
+    /**
+     * @example
+     * ```ts
+     * devServerURL && win.loadURL(devServerURL)
+     * ```
+     */
+    devServerURL,
+    /**
+     * @example
+     * ```ts
+     * win.loadFile(indexHTMLPath)
+     * ```
+     */
+    indexHTMLPath,
+    /**
+     * get path inside entry asar
+     * @param paths joined path
+     */
+    getPathFromEntryAsar(...paths) {
+      return (0, import_node_path.join)(import_electron.app.getAppPath(), entryDirName, ...paths);
+    },
+    /**
+     * get path inside `${app.name}.asar/main`
+     * @param paths joined path
+     */
+    getPathFromMain(...paths) {
+      return (0, import_node_path.join)(mainDirPath, ...paths);
+    },
+    /**
+     * get path inside `${app.name}.asar/preload`
+     * @param paths joined path
+     */
+    getPathFromPreload(...paths) {
+      return (0, import_node_path.join)(preloadDirPath, ...paths);
+    },
+    /**
+     * get path inside public dir
+     * @param paths joined path
+     */
+    getPathFromPublic(...paths) {
+      return (0, import_node_path.join)(publicDirPath, ...paths);
+    }
   };
-  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;
 }
 
 // src/utils/zip.ts
@@ -144,10 +206,7 @@ async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
   });
 }
 
-// src/utils/utils.ts
-var import_node_path2 = require("path");
-var import_node_fs3 = require("fs");
-var import_electron2 = require("electron");
+// src/utils/noDep.ts
 function parseGithubCdnURL(originRepoURL, cdnPrefix, relativeFilePath) {
   if (!originRepoURL.startsWith("https://github.com/")) {
     throw new Error("origin url must start with https://github.com/");
@@ -157,59 +216,54 @@ function parseGithubCdnURL(originRepoURL, cdnPrefix, relativeFilePath) {
   cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
   return originRepoURL.replace("github.com", cdnPrefix) + relativeFilePath;
 }
-function restartApp() {
-  import_electron2.app.relaunch();
-  import_electron2.app.quit();
-}
-function setAppUserModelId(id) {
-  is.win && import_electron2.app.setAppUserModelId(is.dev ? process.execPath : id);
+function handleUnexpectedErrors(callback) {
+  process.on("uncaughtException", callback);
+  process.on("unhandledRejection", callback);
 }
-function setPortableAppDataPath(dirName = "data", create) {
-  if (!is.win) {
-    return;
+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}`);
   }
-  const portablePath = (0, import_node_path2.join)((0, import_node_path2.dirname)(import_electron2.app.getPath("exe")), dirName);
-  let exists = (0, import_node_fs3.existsSync)(portablePath);
-  if (create && !exists) {
-    (0, import_node_fs3.mkdirSync)(portablePath);
-    exists = true;
+  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 (exists) {
-    import_electron2.app.setPath("appData", portablePath);
+  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${version}`);
   }
+  return ret;
 }
-function waitAppReady(timeout = 1e3) {
-  return import_electron2.app.isReady() ? Promise.resolve() : new Promise((resolve, reject) => {
-    const _ = setTimeout(() => {
-      reject(new Error("app is not ready"));
-    }, timeout);
-    import_electron2.app.whenReady().then(() => {
-      clearTimeout(_);
-      resolve();
-    });
-  });
-}
-function handleUnexpectedErrors(callback) {
-  process.on("uncaughtException", callback);
-  process.on("unhandledRejection", callback);
+function isUpdateJSON(json) {
+  const is2 = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  return is2(json) && is2(json?.beta);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DEFAULT_APP_NAME,
-  NoSuchNativeModuleError,
-  getAppVersion,
-  getElectronVersion,
-  getLocale,
-  getProductAsarPath,
+  disableHWAccForWin7,
+  getPathFromAppNameAsar,
+  getPaths,
+  getVersions,
   handleUnexpectedErrors,
   is,
-  isNoSuchNativeModuleError,
+  isUpdateJSON,
+  loadNativeModuleFromEntry,
   parseGithubCdnURL,
   parseVersion,
-  requireNative,
   restartApp,
   setAppUserModelId,
   setPortableAppDataPath,
+  singleInstance,
   unzipFile,
   waitAppReady,
   zipFile

package/dist/utils.mjs

@@ -1,41 +1,39 @@
 import {
-  DEFAULT_APP_NAME,
-  NoSuchNativeModuleError,
-  getAppVersion,
-  getElectronVersion,
-  getLocale,
-  getProductAsarPath,
-  handleUnexpectedErrors,
+  disableHWAccForWin7,
+  getPathFromAppNameAsar,
+  getPaths,
+  getVersions,
   is,
-  isNoSuchNativeModuleError,
-  parseGithubCdnURL,
-  requireNative,
+  loadNativeModuleFromEntry,
   restartApp,
   setAppUserModelId,
   setPortableAppDataPath,
+  singleInstance,
   waitAppReady
-} from "./chunk-6UZHBPFT.mjs";
+} from "./chunk-OUZLSVQC.mjs";
 import {
+  handleUnexpectedErrors,
+  isUpdateJSON,
+  parseGithubCdnURL,
   parseVersion,
   unzipFile,
   zipFile
-} from "./chunk-CMBFI77K.mjs";
+} from "./chunk-GB6VLKJZ.mjs";
 export {
-  DEFAULT_APP_NAME,
-  NoSuchNativeModuleError,
-  getAppVersion,
-  getElectronVersion,
-  getLocale,
-  getProductAsarPath,
+  disableHWAccForWin7,
+  getPathFromAppNameAsar,
+  getPaths,
+  getVersions,
   handleUnexpectedErrors,
   is,
-  isNoSuchNativeModuleError,
+  isUpdateJSON,
+  loadNativeModuleFromEntry,
   parseGithubCdnURL,
   parseVersion,
-  requireNative,
   restartApp,
   setAppUserModelId,
   setPortableAppDataPath,
+  singleInstance,
   unzipFile,
   waitAppReady,
   zipFile