electron-version-deployer-cli 0.0.1

package/dist/main.cjs.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const electron = require("electron");
+const node_url = require("node:url");
+const node_path = require("node:path");
+const node_https = require("node:https");
+const node_fs = require("node:fs");
+const extract = require("extract-zip");
+function fetchRemoteChangelogJSON(remote_url) {
+  return new Promise((res, rej) => {
+    node_https.get(`${remote_url}/changelog.json`, (_res) => {
+      let data = "";
+      _res.on("data", (chunk) => {
+        data += chunk;
+      });
+      _res.on("end", () => {
+        try {
+          res(JSON.parse(data));
+        } catch (e) {
+          res(null);
+        }
+      });
+    }).on("error", (err) => {
+      rej(`获取 changelog.json 失败:` + err.toString());
+    });
+  });
+}
+function fetchRemotePkgJSON(remote_url) {
+  return new Promise((res, rej) => {
+    node_https.get(`${remote_url}/package.json`, (_res) => {
+      let data = "";
+      _res.on("data", (chunk) => {
+        data += chunk;
+      });
+      _res.on("end", () => {
+        try {
+          res(JSON.parse(data));
+        } catch (e) {
+          res(null);
+        }
+      });
+    }).on("error", (err) => {
+      rej(`自动更新检查请求失败:` + err.toString());
+    });
+  });
+}
+function versionToNum(a) {
+  let c = a.split(".");
+  let num_place = ["", "0", "00", "000", "0000"], r = num_place.reverse();
+  for (let i = 0; i < c.length; i++) {
+    let len = c[i].length;
+    c[i] = r[len] + c[i];
+  }
+  let res = c.join("");
+  return res;
+}
+function compareObjectsIsEqual(obj1, obj2) {
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (let key of keys1) {
+    if (obj1[key] !== obj2[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+const CLI_NAME = "electron-version-deployer-cli";
+const id = `${Date.now()}-${Math.random()}`;
+var EVDEventEnum = /* @__PURE__ */ ((EVDEventEnum2) => {
+  EVDEventEnum2["OPEN_LINK"] = "evd-open-link";
+  EVDEventEnum2["UPDATE"] = "evd-update-now";
+  EVDEventEnum2["SKIP"] = "evd-skip";
+  EVDEventEnum2["GET_CHANGELOGS"] = "evd-get-change-logs";
+  return EVDEventEnum2;
+})(EVDEventEnum || {});
+let globalArgs = null;
+let cacheCurrentPkgJSON = null;
+function EVDInit(props) {
+  globalArgs = props;
+  const { detectionFrequency, detectAtStart, onError } = getConfigs();
+  setInterval(async () => {
+    try {
+      await EVDCheckUpdate();
+    } catch (e) {
+      onError(e);
+    }
+  }, 1e3 * detectionFrequency);
+  if (!detectAtStart)
+    return;
+  setTimeout(async () => {
+    try {
+      await EVDCheckUpdate();
+    } catch (e) {
+      onError(e);
+    }
+  }, 1e3 * 2);
+  const appPath = electron.app.getAppPath();
+  cacheCurrentPkgJSON = JSON.parse(
+    node_fs.readFileSync(node_path.join(appPath, "package.json"), "utf-8")
+  );
+}
+async function EVDCheckUpdate() {
+  const { netlifyUrl } = getConfigs();
+  const { version } = cacheCurrentPkgJSON;
+  const remoteJSON = await fetchRemotePkgJSON(netlifyUrl);
+  if (!remoteJSON)
+    throw new Error(`${netlifyUrl}package.json 文件不存在`);
+  const localVersion = versionToNum(version);
+  const remoteVersion = versionToNum(remoteJSON.version);
+  if (remoteVersion > localVersion) {
+    await showNewVersionDialog();
+  }
+}
+async function showNewVersionDialog() {
+  const { windowHeight, windowWidth, onError } = getConfigs();
+  electron.app.whenReady().then(async () => {
+    try {
+      let promptWindow = new electron.BrowserWindow({
+        frame: true,
+        width: windowWidth,
+        height: windowHeight,
+        minWidth: windowWidth,
+        minHeight: windowHeight,
+        resizable: false,
+        minimizable: true,
+        fullscreenable: false,
+        maximizable: false,
+        skipTaskbar: true,
+        alwaysOnTop: true,
+        useContentSize: false,
+        title: "有可用的更新",
+        webPreferences: {
+          nodeIntegration: true,
+          contextIsolation: false
+        },
+        show: false
+      });
+      promptWindow.setMenu(null);
+      promptWindow.setMenuBarVisibility(false);
+      const promptUrl = node_url.format({
+        protocol: "file",
+        slashes: true,
+        pathname: node_path.join(
+          electron.app.getAppPath(),
+          "node_modules",
+          CLI_NAME,
+          "dist",
+          "templates",
+          "newVersionDialog.html"
+        ),
+        hash: id
+      });
+      promptWindow.loadURL(promptUrl);
+      promptWindow.once("ready-to-show", () => {
+        promptWindow.show();
+      });
+      promptWindow.once("close", () => {
+        cleanup(promptWindow);
+      });
+      bindEvent(promptWindow);
+    } catch (e) {
+      onError(e);
+    }
+  });
+}
+async function installNewVersion() {
+  const { netlifyUrl } = getConfigs();
+  const remoteJSON = await fetchRemotePkgJSON(netlifyUrl);
+  const needInstallFullSize = compareObjectsIsEqual(
+    remoteJSON.dependencies,
+    cacheCurrentPkgJSON.dependencies
+  );
+  try {
+    await installPkg(needInstallFullSize ? "fullCode.zip" : "logicCode.zip");
+  } catch (error) {
+    node_fs.appendFileSync(
+      node_path.join(electron.app.getPath("userData"), "evd-runtime-error.txt"),
+      `
+    ${(/* @__PURE__ */ new Date()).toString()}
+
+    ${error.toString()}
+
+    -- stack
+
+    ${error.stack}
+
+    ----------------------------------------------------------------
+
+  `
+    );
+  }
+}
+async function installPkg(zipFile) {
+  const { netlifyUrl } = getConfigs();
+  const appPath = electron.app.getAppPath();
+  const unzipPath = node_path.join(appPath, "evdUnzip");
+  if (node_fs.existsSync(unzipPath)) {
+    node_fs.rmSync(unzipPath, {
+      force: true,
+      maxRetries: 3,
+      recursive: true
+    });
+  }
+  node_fs.mkdirSync(unzipPath);
+  const tmpZipFilePath = node_fs.createWriteStream(unzipPath + ".zip");
+  await new Promise(
+    (res, rej) => node_https.get(`${netlifyUrl}/${zipFile}`, (response) => {
+      response.pipe(tmpZipFilePath).on("finish", () => {
+        res();
+      }).on("error", (err) => {
+        rej(err);
+      });
+    }).on("error", (err) => {
+      rej(err);
+    })
+  );
+  await extract(unzipPath + ".zip", { dir: unzipPath });
+  await new Promise((res) => setTimeout(res, 1e3));
+  copyFolderRecursiveSync(unzipPath, appPath);
+  await new Promise((res) => setTimeout(res, 1e3));
+}
+function bindEvent(promptWindow) {
+  electron.ipcMain.on("evd-open-link", (_, link) => {
+    electron.shell.openExternal(link);
+  });
+  electron.ipcMain.on("evd-skip", (_) => {
+    promptWindow.close();
+  });
+  electron.ipcMain.on("evd-update-now", (_) => {
+    installNewVersion().then(() => {
+      console.log(222);
+      promptWindow.close();
+      electron.app.relaunch();
+      electron.app.exit();
+    });
+  });
+  electron.ipcMain.handle("evd-get-change-logs", async () => {
+    const { netlifyUrl } = getConfigs();
+    return await fetchRemoteChangelogJSON(netlifyUrl);
+  });
+}
+function cleanup(promptWindow) {
+  electron.ipcMain.removeAllListeners(
+    "evd-open-link"
+    /* OPEN_LINK */
+  );
+  electron.ipcMain.removeAllListeners(
+    "evd-skip"
+    /* SKIP */
+  );
+  electron.ipcMain.removeAllListeners(
+    "evd-update-now"
+    /* UPDATE */
+  );
+  promptWindow == null ? void 0 : promptWindow.focus();
+  if (promptWindow) {
+    promptWindow.destroy();
+  }
+}
+function getConfigs() {
+  if (!globalArgs)
+    throw new Error("必须先执行 EVDInit 后才能继续运行！");
+  return {
+    ...{
+      onError: () => {
+      },
+      windowHeight: 360,
+      windowWidth: 400,
+      logo: void 0,
+      //  默认六小时检测一次
+      detectionFrequency: 60 * 60 * 6,
+      detectAtStart: true
+    },
+    ...globalArgs
+  };
+}
+function copyFileSync(source, target) {
+  let targetFile = target;
+  if (node_fs.existsSync(target)) {
+    if (node_fs.statSync(target).isDirectory()) {
+      targetFile = node_path.join(target, node_path.basename(source));
+    }
+  }
+  node_fs.writeFileSync(targetFile, node_fs.readFileSync(source));
+}
+function copyFolderRecursiveSync(source, target) {
+  if (!node_fs.existsSync(target)) {
+    node_fs.mkdirSync(target);
+  }
+  const files = node_fs.readdirSync(source);
+  files.forEach((file) => {
+    const sourcePath = node_path.join(source, file);
+    const targetPath = node_path.join(target, file);
+    if (node_fs.statSync(sourcePath).isDirectory()) {
+      copyFolderRecursiveSync(sourcePath, targetPath);
+    } else {
+      copyFileSync(sourcePath, targetPath);
+    }
+  });
+}
+exports.EVDCheckUpdate = EVDCheckUpdate;
+exports.EVDEventEnum = EVDEventEnum;
+exports.EVDInit = EVDInit;

package/dist/main.d.ts

@@ -0,0 +1,18 @@
+export declare enum EVDEventEnum {
+    OPEN_LINK = "evd-open-link",
+    UPDATE = "evd-update-now",
+    SKIP = "evd-skip",
+    GET_CHANGELOGS = "evd-get-change-logs"
+}
+type EVDInitPropsType = {
+    netlifyUrl: string;
+    windowWidth?: number;
+    windowHeight?: number;
+    logo?: string;
+    detectionFrequency?: number;
+    detectAtStart?: number;
+    onError?: (err: unknown) => void;
+};
+export declare function EVDInit(props: EVDInitPropsType): void;
+export declare function EVDCheckUpdate(): Promise<void>;
+export {};

package/dist/main.es.js

@@ -0,0 +1,306 @@
+import { app, BrowserWindow, ipcMain, shell } from "electron";
+import { format } from "node:url";
+import { join, basename } from "node:path";
+import { get } from "node:https";
+import { readFileSync, appendFileSync, existsSync, rmSync, mkdirSync, createWriteStream, readdirSync, statSync, writeFileSync } from "node:fs";
+import extract from "extract-zip";
+function fetchRemoteChangelogJSON(remote_url) {
+  return new Promise((res, rej) => {
+    get(`${remote_url}/changelog.json`, (_res) => {
+      let data = "";
+      _res.on("data", (chunk) => {
+        data += chunk;
+      });
+      _res.on("end", () => {
+        try {
+          res(JSON.parse(data));
+        } catch (e) {
+          res(null);
+        }
+      });
+    }).on("error", (err) => {
+      rej(`获取 changelog.json 失败:` + err.toString());
+    });
+  });
+}
+function fetchRemotePkgJSON(remote_url) {
+  return new Promise((res, rej) => {
+    get(`${remote_url}/package.json`, (_res) => {
+      let data = "";
+      _res.on("data", (chunk) => {
+        data += chunk;
+      });
+      _res.on("end", () => {
+        try {
+          res(JSON.parse(data));
+        } catch (e) {
+          res(null);
+        }
+      });
+    }).on("error", (err) => {
+      rej(`自动更新检查请求失败:` + err.toString());
+    });
+  });
+}
+function versionToNum(a) {
+  let c = a.split(".");
+  let num_place = ["", "0", "00", "000", "0000"], r = num_place.reverse();
+  for (let i = 0; i < c.length; i++) {
+    let len = c[i].length;
+    c[i] = r[len] + c[i];
+  }
+  let res = c.join("");
+  return res;
+}
+function compareObjectsIsEqual(obj1, obj2) {
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (let key of keys1) {
+    if (obj1[key] !== obj2[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+const CLI_NAME = "electron-version-deployer-cli";
+const id = `${Date.now()}-${Math.random()}`;
+var EVDEventEnum = /* @__PURE__ */ ((EVDEventEnum2) => {
+  EVDEventEnum2["OPEN_LINK"] = "evd-open-link";
+  EVDEventEnum2["UPDATE"] = "evd-update-now";
+  EVDEventEnum2["SKIP"] = "evd-skip";
+  EVDEventEnum2["GET_CHANGELOGS"] = "evd-get-change-logs";
+  return EVDEventEnum2;
+})(EVDEventEnum || {});
+let globalArgs = null;
+let cacheCurrentPkgJSON = null;
+function EVDInit(props) {
+  globalArgs = props;
+  const { detectionFrequency, detectAtStart, onError } = getConfigs();
+  setInterval(async () => {
+    try {
+      await EVDCheckUpdate();
+    } catch (e) {
+      onError(e);
+    }
+  }, 1e3 * detectionFrequency);
+  if (!detectAtStart)
+    return;
+  setTimeout(async () => {
+    try {
+      await EVDCheckUpdate();
+    } catch (e) {
+      onError(e);
+    }
+  }, 1e3 * 2);
+  const appPath = app.getAppPath();
+  cacheCurrentPkgJSON = JSON.parse(
+    readFileSync(join(appPath, "package.json"), "utf-8")
+  );
+}
+async function EVDCheckUpdate() {
+  const { netlifyUrl } = getConfigs();
+  const { version } = cacheCurrentPkgJSON;
+  const remoteJSON = await fetchRemotePkgJSON(netlifyUrl);
+  if (!remoteJSON)
+    throw new Error(`${netlifyUrl}package.json 文件不存在`);
+  const localVersion = versionToNum(version);
+  const remoteVersion = versionToNum(remoteJSON.version);
+  if (remoteVersion > localVersion) {
+    await showNewVersionDialog();
+  }
+}
+async function showNewVersionDialog() {
+  const { windowHeight, windowWidth, onError } = getConfigs();
+  app.whenReady().then(async () => {
+    try {
+      let promptWindow = new BrowserWindow({
+        frame: true,
+        width: windowWidth,
+        height: windowHeight,
+        minWidth: windowWidth,
+        minHeight: windowHeight,
+        resizable: false,
+        minimizable: true,
+        fullscreenable: false,
+        maximizable: false,
+        skipTaskbar: true,
+        alwaysOnTop: true,
+        useContentSize: false,
+        title: "有可用的更新",
+        webPreferences: {
+          nodeIntegration: true,
+          contextIsolation: false
+        },
+        show: false
+      });
+      promptWindow.setMenu(null);
+      promptWindow.setMenuBarVisibility(false);
+      const promptUrl = format({
+        protocol: "file",
+        slashes: true,
+        pathname: join(
+          app.getAppPath(),
+          "node_modules",
+          CLI_NAME,
+          "dist",
+          "templates",
+          "newVersionDialog.html"
+        ),
+        hash: id
+      });
+      promptWindow.loadURL(promptUrl);
+      promptWindow.once("ready-to-show", () => {
+        promptWindow.show();
+      });
+      promptWindow.once("close", () => {
+        cleanup(promptWindow);
+      });
+      bindEvent(promptWindow);
+    } catch (e) {
+      onError(e);
+    }
+  });
+}
+async function installNewVersion() {
+  const { netlifyUrl } = getConfigs();
+  const remoteJSON = await fetchRemotePkgJSON(netlifyUrl);
+  const needInstallFullSize = compareObjectsIsEqual(
+    remoteJSON.dependencies,
+    cacheCurrentPkgJSON.dependencies
+  );
+  try {
+    await installPkg(needInstallFullSize ? "fullCode.zip" : "logicCode.zip");
+  } catch (error) {
+    appendFileSync(
+      join(app.getPath("userData"), "evd-runtime-error.txt"),
+      `
+    ${(/* @__PURE__ */ new Date()).toString()}
+
+    ${error.toString()}
+
+    -- stack
+
+    ${error.stack}
+
+    ----------------------------------------------------------------
+
+  `
+    );
+  }
+}
+async function installPkg(zipFile) {
+  const { netlifyUrl } = getConfigs();
+  const appPath = app.getAppPath();
+  const unzipPath = join(appPath, "evdUnzip");
+  if (existsSync(unzipPath)) {
+    rmSync(unzipPath, {
+      force: true,
+      maxRetries: 3,
+      recursive: true
+    });
+  }
+  mkdirSync(unzipPath);
+  const tmpZipFilePath = createWriteStream(unzipPath + ".zip");
+  await new Promise(
+    (res, rej) => get(`${netlifyUrl}/${zipFile}`, (response) => {
+      response.pipe(tmpZipFilePath).on("finish", () => {
+        res();
+      }).on("error", (err) => {
+        rej(err);
+      });
+    }).on("error", (err) => {
+      rej(err);
+    })
+  );
+  await extract(unzipPath + ".zip", { dir: unzipPath });
+  await new Promise((res) => setTimeout(res, 1e3));
+  copyFolderRecursiveSync(unzipPath, appPath);
+  await new Promise((res) => setTimeout(res, 1e3));
+}
+function bindEvent(promptWindow) {
+  ipcMain.on("evd-open-link", (_, link) => {
+    shell.openExternal(link);
+  });
+  ipcMain.on("evd-skip", (_) => {
+    promptWindow.close();
+  });
+  ipcMain.on("evd-update-now", (_) => {
+    installNewVersion().then(() => {
+      console.log(222);
+      promptWindow.close();
+      app.relaunch();
+      app.exit();
+    });
+  });
+  ipcMain.handle("evd-get-change-logs", async () => {
+    const { netlifyUrl } = getConfigs();
+    return await fetchRemoteChangelogJSON(netlifyUrl);
+  });
+}
+function cleanup(promptWindow) {
+  ipcMain.removeAllListeners(
+    "evd-open-link"
+    /* OPEN_LINK */
+  );
+  ipcMain.removeAllListeners(
+    "evd-skip"
+    /* SKIP */
+  );
+  ipcMain.removeAllListeners(
+    "evd-update-now"
+    /* UPDATE */
+  );
+  promptWindow == null ? void 0 : promptWindow.focus();
+  if (promptWindow) {
+    promptWindow.destroy();
+  }
+}
+function getConfigs() {
+  if (!globalArgs)
+    throw new Error("必须先执行 EVDInit 后才能继续运行！");
+  return {
+    ...{
+      onError: () => {
+      },
+      windowHeight: 360,
+      windowWidth: 400,
+      logo: void 0,
+      //  默认六小时检测一次
+      detectionFrequency: 60 * 60 * 6,
+      detectAtStart: true
+    },
+    ...globalArgs
+  };
+}
+function copyFileSync(source, target) {
+  let targetFile = target;
+  if (existsSync(target)) {
+    if (statSync(target).isDirectory()) {
+      targetFile = join(target, basename(source));
+    }
+  }
+  writeFileSync(targetFile, readFileSync(source));
+}
+function copyFolderRecursiveSync(source, target) {
+  if (!existsSync(target)) {
+    mkdirSync(target);
+  }
+  const files = readdirSync(source);
+  files.forEach((file) => {
+    const sourcePath = join(source, file);
+    const targetPath = join(target, file);
+    if (statSync(sourcePath).isDirectory()) {
+      copyFolderRecursiveSync(sourcePath, targetPath);
+    } else {
+      copyFileSync(sourcePath, targetPath);
+    }
+  });
+}
+export {
+  EVDCheckUpdate,
+  EVDEventEnum,
+  EVDInit
+};

package/dist/templates/evd.config.ts

@@ -0,0 +1,19 @@
+// @ts-nocheck
+import { defineEVDConfig } from "@/index";
+
+export default defineEVDConfig({
+  compileCommand: __compileCommand__,
+  changelogsPath: __changelogsPath__,
+  sources: {
+    folder: __sources_folder__,
+    nodeModules: __sources_nodeModules__,
+    codes: __sources_codes__,
+    packageJSON: __sources_packageJSON__,
+  },
+  netlify: {
+    url: __netlify_url__,
+    token: __netlify_token__,
+    siteID: __netlify_siteID__,
+  },
+  prebuiltConfig: {},
+});