akey-umi-plugin-electron-builder 4.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 BySlin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# umi-plugin-electron-builder
+
+本插件提供基于umijs的electron的开发及打包，无需修改项目结构，支持混合项目结构和main+renderer项目结构，仅支持 umijs4
+
+混合项目结构示例 <a href="https://github.com/BySlin/umi-plugin-electron-builder/tree/main/examples/demo">点此访问</a>
+
+main+renderer项目结构示例 <a href="https://github.com/BySlin/umi-plugin-electron-builder/tree/main/examples/main%2Brenderer">点此访问</a>
+
+使用混合项目结构时，插件可自动生成项目文件，使用main+renderer项目结构时，请参考示例修改目录结构
+
+<a href="https://www.npmjs.com/package/umi-plugin-electron-builder"><img src="https://img.shields.io/npm/v/umi-plugin-electron-builder.svg?sanitize=true" alt="Version"></a>
+
+[更新日志](https://github.com/BySlin/umi-plugin-electron-builder/blob/main/CHANGELOG.md)
+
+[umi3请使用2.x版本插件，点此访问](https://github.com/BySlin/umi-plugin-electron-builder/tree/2.x)
+
+## 安装
+
+```shell
+$ yarn add umi-plugin-electron-builder --dev
+```
+
+umi4需要手动启用插件
+
+```typescript
+import { defineConfig } from "umi";
+
+export default defineConfig({
+  npmClient: "yarn",
+  plugins: ["umi-plugin-electron-builder"],
+});
+```
+
+配置完成之后，执行
+
+```shell
+$ yarn postinstall
+```
+
+执行以下指令，生成主进程文件 src/main/index.ts
+
+```shell
+$ yarn electron:init
+```
+
+默认安装最新版本的 electron
+
+自动在 package.json 增加以下配置，使用@umijs/max时，请将以下命令中的umi修改为max
+
+```json5
+{
+  scripts: {
+    'rebuild-deps': 'electron-builder install-app-deps',
+    'electron:init': 'umi electron init',
+    'electron:dev': 'umi dev electron',
+    'electron:build:win': 'umi build electron --win',
+    'electron:build:mac': 'umi build electron --mac',
+    'electron:build:linux': 'umi build electron --linux',
+  },
+  //这里需要修改成你自己的应用名称
+  name: 'electron_builder_app',
+  version: '0.0.1',
+}
+```
+
+### Electron 版本降级
+
+你可以手动将 package.json 中的 electron 修改至低版本，插件与 electron 版本无关
+
+### 开发
+
+```
+$ yarn electron:dev
+```
+
+### 调试主进程（VS Code）
+
+```json5
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node-terminal",
+      "request": "launch",
+      "name": "debug electron:dev",
+      "command": "yarn electron:dev",
+      "skipFiles": [
+        "<node_internals>/**"
+      ],
+      "sourceMapPathOverrides": {
+        "webpack://main/./*": "${workspaceFolder}/src/main/*"
+      },
+      "resolveSourceMapLocations": [
+        "${workspaceFolder}/src/.umi/electron/**",
+        "${workspaceFolder}/src/renderer/.umi/electron/**"
+      ],
+      "autoAttachChildProcesses": true
+    }
+  ]
+}
+```
+
+### 打包
+
+打包路径不能有中文，electron-builder不能跨平台打包，请在对应系统上打包
+
+```
+//windows
+$ umi build electron --win
+//mac
+$ umi build electron --mac
+//linux
+$ umi build electron --linux
+//按平台打包
+$ umi build electron --win --ia32    //32位
+$ umi build electron --win --x64     //64位
+$ umi build electron --win --armv7l  //arm32位
+$ umi build electron --win --arm64   //arm64位
+```
+
+### 使用 node 环境下运行的模块
+
+例：使用 serialport 插件
+
+```
+$ yarn add serialport @types/serialport
+```
+
+### 配置 .umirc.ts
+
+```typescript
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { defineConfig } from 'umi';
+import { InlineConfig } from 'vite';
+
+export default defineConfig({
+  electronBuilder: {
+    //可选参数
+    buildType: 'vite', //webpack或vite，当编译出现问题，可尝试切换为webpack
+    //并行构建，默认关闭，如开启出现问题，请关闭此功能
+    parallelBuild: false, //并行构建，开启时主进程和渲染进程同时编译
+    mainSrc: 'src/main', //默认主进程目录
+    preloadSrc: 'src/preload', //默认preload目录，可选，不需要可删除
+    routerMode: 'hash', //路由 hash或memory,仅electron下有效，推荐使用hash
+    outputDir: 'dist_electron', //默认打包目录
+    externals: ['serialport'], //node原生模块配置，打包之后找不到包也需要配置在这里
+    rendererTarget: 'web', //构建目标electron-renderer或web，使用上下文隔离时，必须设置为web
+    debugPort: 5858, //主进程调试端口
+    //2.1.0新增
+    preloadEntry: {
+      //默认值 key为preload文件名 值为preload输出文件名
+      //输出文件名不能为main.js会和主进程文件名冲突
+      //文件名为preload目录下多文件名
+      //多级目录时key为xxxx/xxxx.ts
+      //使用时输出文件会和主进程在同一目录下 preload: path.join(__dirname, 'preload.js')
+      'index.ts': 'preload.js',
+    },
+    viteConfig(config: InlineConfig, type: "main" | "preload") {
+      //主进程Vite配置
+      //配置参考 https://vitejs.dev/config/
+      //ConfigType分为main和preload可分别配置
+    },
+    //通过 webpack-chain 的 API 修改 webpack 配置。
+    mainWebpackChain(config: Config, type: "main" | "preload") {
+      //ConfigType分为main和preload可分别配置
+      // if (type === 'main') {}
+      // if (type === 'preload') {}
+    },
+    //2.1.10新增 开启自定义主进程日志时
+    logProcess(log: string, type: "normal" | "error") {
+      if (type === 'normal') {
+        console.log(log);
+      } else if (type === 'error') {
+        console.error(log);
+      }
+    },
+    builderOptions: {
+      //配置参考 https://www.electron.build/configuration/configuration
+      appId: 'com.test.test',
+      productName: '测试',
+      publish: [
+        {
+          provider: 'generic',
+          url: 'http://localhost/test',
+        },
+      ],
+    }, //electronBuilder参数
+  },
+  routes: [{ path: '/', component: '@/pages/index' }],
+});
+```
+
+在 Electron10 以上使用[contextIsolation](https://www.electronjs.org/docs/tutorial/context-isolation)时 rendererTarget 需要设置成
+web
+
+builderOptions[参考 Electron Builder](https://www.electron.build/configuration/configuration)
+
+### 已知问题
+
+esbuild 暂不支持 typescript decorator metadata
+
+Vite 与 typeorm 冲突，typeorm 在主进程无法使用
+
+相关 Issue https://github.com/evanw/esbuild/issues/257

package/lib/compile/index.js

@@ -0,0 +1,168 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/compile/index.ts
+var compile_exports = {};
+__export(compile_exports, {
+  runBuild: () => runBuild,
+  runDev: () => runDev
+});
+module.exports = __toCommonJS(compile_exports);
+var import_utils = require("@umijs/utils");
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"));
+var import_vite = require("vite");
+var import_utils2 = require("../utils");
+var import_vite2 = require("./vite");
+var import_webpack = require("./webpack");
+var TIMEOUT = 500;
+var buildMain = (api) => {
+  const { buildType } = api.config.electronBuilder;
+  if (buildType === "webpack") {
+    return (0, import_webpack.build)((0, import_webpack.getMainWebpackConfig)(api));
+  } else {
+    return (0, import_vite.build)((0, import_vite2.getMainViteConfig)(api));
+  }
+};
+var buildPreload = (api) => {
+  const { preloadEntry, buildType } = api.config.electronBuilder;
+  if (import_utils.fsExtra.pathExistsSync((0, import_utils2.getPreloadSrc)(api))) {
+    const tasks = [];
+    if (buildType === "webpack") {
+      for (let inputFileName in preloadEntry) {
+        tasks.push(
+          (0, import_webpack.build)(
+            (0, import_webpack.getPreloadWebpackConfig)(
+              api,
+              inputFileName,
+              preloadEntry[inputFileName]
+            )
+          )
+        );
+      }
+    } else {
+      for (let inputFileName in preloadEntry) {
+        tasks.push(
+          (0, import_vite.build)(
+            (0, import_vite2.getPreloadViteConfig)(
+              api,
+              inputFileName,
+              preloadEntry[inputFileName]
+            )
+          )
+        );
+      }
+    }
+    return Promise.all(tasks);
+  }
+  return Promise.resolve();
+};
+var runDev = async (api) => {
+  const { logProcess, debugPort, parallelBuild } = api.config.electronBuilder;
+  const electronPath = require(import_path.default.join((0, import_utils2.getNodeModulesPath)(), "electron"));
+  let spawnProcess = null;
+  const runMain = (0, import_utils2.debounce)(() => {
+    if (spawnProcess !== null) {
+      spawnProcess.kill("SIGKILL");
+      spawnProcess = null;
+    }
+    spawnProcess = (0, import_child_process.spawn)(String(electronPath), [
+      `--inspect=${debugPort}`,
+      import_path.default.join((0, import_utils2.getDevBuildDir)(api), "main.js")
+    ]);
+    spawnProcess.stdout.on("data", (data) => {
+      const log = (0, import_utils2.filterText)(data.toString());
+      if (log) {
+        logProcess(log, "normal");
+      }
+    });
+    spawnProcess.stderr.on("data", (data) => {
+      const log = (0, import_utils2.filterText)(data.toString());
+      if (log) {
+        logProcess(log, "error");
+      }
+    });
+    spawnProcess.on("close", (code, signal) => {
+      if (signal != "SIGKILL") {
+        process.exit(-1);
+      }
+    });
+    return spawnProcess;
+  }, TIMEOUT);
+  const buildMainDebounced = (0, import_utils2.debounce)(() => buildMain(api), TIMEOUT);
+  const buildPreloadDebounced = (0, import_utils2.debounce)(() => buildPreload(api), TIMEOUT);
+  const runPreload = (0, import_utils2.debounce)(() => {
+  }, TIMEOUT);
+  if (!parallelBuild) {
+    await Promise.all([buildMain(api), buildPreload(api)]);
+  }
+  const watcher = import_utils.chokidar.watch(
+    [
+      `${(0, import_utils2.getMainSrc)(api)}/**`,
+      `${(0, import_utils2.getPreloadSrc)(api)}/**`,
+      `${(0, import_utils2.getDevBuildDir)(api)}/**`
+    ],
+    { ignoreInitial: true }
+  );
+  watcher.on("unlink", (path2) => {
+    if (spawnProcess !== null && path2.includes((0, import_utils2.getDevBuildDir)(api))) {
+      spawnProcess.kill("SIGINT");
+      spawnProcess = null;
+    }
+  }).on("add", (path2) => {
+    if (path2.includes((0, import_utils2.getDevBuildDir)(api))) {
+      return runMain();
+    }
+    if (spawnProcess !== void 0 && path2.includes("preload.js")) {
+      return runPreload();
+    }
+  }).on("change", (path2) => {
+    if (path2.includes((0, import_utils2.getMainSrc)(api))) {
+      return buildMainDebounced();
+    }
+    if (path2.includes("main.js")) {
+      return runMain();
+    }
+    if (path2.includes((0, import_utils2.getPreloadSrc)(api))) {
+      return buildPreloadDebounced();
+    }
+    if (path2.includes("preload.js")) {
+      return runPreload();
+    }
+  });
+  await runMain();
+};
+var runBuild = async (api) => {
+  await buildMain(api);
+  await buildPreload(api);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runBuild,
+  runDev
+});

package/lib/compile/vite/index.js

@@ -0,0 +1,111 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/compile/vite/index.ts
+var vite_exports = {};
+__export(vite_exports, {
+  getMainViteConfig: () => getMainViteConfig,
+  getPreloadViteConfig: () => getPreloadViteConfig
+});
+module.exports = __toCommonJS(vite_exports);
+var import_external_packages = __toESM(require("../../external-packages.config"));
+var path = __toESM(require("path"));
+var import_utils = require("../../utils");
+function getMainViteConfig(api) {
+  const mode = api.env || "development";
+  const { externals, viteConfig } = api.config.electronBuilder;
+  const external = [...import_external_packages.default, ...externals];
+  const mainConfig = {
+    mode,
+    resolve: {
+      alias: {
+        "@/common": path.join(process.cwd(), "src/common"),
+        "@": (0, import_utils.getMainSrc)(api)
+      }
+    },
+    root: (0, import_utils.getMainSrc)(api),
+    build: {
+      sourcemap: mode === "development" ? "inline" : false,
+      outDir: mode === "development" ? (0, import_utils.getDevBuildDir)(api) : (0, import_utils.getBuildDir)(api),
+      assetsDir: ".",
+      minify: mode !== "development",
+      lib: {
+        entry: "index.ts",
+        formats: ["cjs"]
+      },
+      rollupOptions: {
+        external,
+        output: {
+          entryFileNames: "main.js"
+        }
+      },
+      emptyOutDir: false
+    }
+  };
+  viteConfig(mainConfig, "main");
+  return mainConfig;
+}
+function getPreloadViteConfig(api, inputFileName, outputFileName) {
+  const mode = api.env || "development";
+  const { externals, viteConfig } = api.config.electronBuilder;
+  const external = [...import_external_packages.default, ...externals];
+  const preloadConfig = {
+    mode,
+    resolve: {
+      alias: {
+        "@/common": path.join(process.cwd(), "src/common"),
+        "@": (0, import_utils.getPreloadSrc)(api)
+      }
+    },
+    root: (0, import_utils.getPreloadSrc)(api),
+    build: {
+      sourcemap: mode === "development" ? "inline" : false,
+      outDir: mode === "development" ? (0, import_utils.getDevBuildDir)(api) : (0, import_utils.getBuildDir)(api),
+      assetsDir: ".",
+      minify: mode !== "development",
+      lib: {
+        entry: inputFileName,
+        formats: ["cjs"]
+      },
+      rollupOptions: {
+        external,
+        output: {
+          entryFileNames: outputFileName
+        }
+      },
+      emptyOutDir: false
+    }
+  };
+  viteConfig(preloadConfig, "preload");
+  return preloadConfig;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMainViteConfig,
+  getPreloadViteConfig
+});

package/lib/compile/webpack/index.js

@@ -0,0 +1,101 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/compile/webpack/index.ts
+var webpack_exports = {};
+__export(webpack_exports, {
+  build: () => build,
+  getMainWebpackConfig: () => getMainWebpackConfig,
+  getPreloadWebpackConfig: () => getPreloadWebpackConfig
+});
+module.exports = __toCommonJS(webpack_exports);
+var import_path = __toESM(require("path"));
+var import_webpack = __toESM(require("@umijs/bundler-webpack/compiled/webpack"));
+var import_webpack_5_chain = __toESM(require("@umijs/bundler-webpack/compiled/webpack-5-chain"));
+var import_external_packages = __toESM(require("../../external-packages.config"));
+var import_utils = require("../../utils");
+function getBaseWebpackConfig(api) {
+  const mode = api.env === "development" ? "development" : "production";
+  const { externals } = api.config.electronBuilder;
+  const external = [...import_external_packages.default, ...externals];
+  const config = new import_webpack_5_chain.default();
+  config.mode(mode);
+  config.node.set("__filename", false).set("__dirname", false);
+  config.devtool(mode === "development" ? "inline-source-map" : false);
+  config.resolve.extensions.add(".ts").add(".js").add(".node");
+  config.module.rule("ts").exclude.add(/node_modules/);
+  config.module.rule("ts").test(/\.ts?$/).use("ts").loader("ts-loader").options({ transpileOnly: true });
+  config.resolve.alias.set("@/common", import_path.default.join(process.cwd(), "src/common"));
+  config.externals(external);
+  config.output.path(
+    mode === "development" ? (0, import_utils.getDevBuildDir)(api) : (0, import_utils.getBuildDir)(api)
+  );
+  return config;
+}
+function getMainWebpackConfig(api) {
+  const { mainWebpackChain } = api.config.electronBuilder;
+  const config = getBaseWebpackConfig(api);
+  config.resolve.alias.set("@", (0, import_utils.getMainSrc)(api));
+  config.context((0, import_utils.getMainSrc)(api));
+  config.entry("main").add("./index.ts");
+  config.output.filename("main.js");
+  config.target("electron-main");
+  config.output.library("main").libraryTarget("commonjs2");
+  mainWebpackChain(config, "main");
+  return config.toConfig();
+}
+function getPreloadWebpackConfig(api, inputFileName, outputFileName) {
+  const { mainWebpackChain } = api.config.electronBuilder;
+  const config = getBaseWebpackConfig(api);
+  config.resolve.alias.set("@", (0, import_utils.getPreloadSrc)(api));
+  config.context((0, import_utils.getPreloadSrc)(api));
+  config.entry("preload").add(`./${inputFileName}`);
+  config.output.filename(outputFileName);
+  config.target("electron-renderer");
+  config.output.library("preload").libraryTarget("commonjs2");
+  mainWebpackChain(config, "preload");
+  return config.toConfig();
+}
+var build = async (config) => {
+  return await new Promise((resolve, reject) => {
+    const compiler = (0, import_webpack.default)(config);
+    compiler.run((err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  getMainWebpackConfig,
+  getPreloadWebpackConfig
+});

package/lib/external-packages.config.js

@@ -0,0 +1,76 @@
+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/external-packages.config.ts
+var external_packages_config_exports = {};
+__export(external_packages_config_exports, {
+  builtins: () => builtins,
+  default: () => external_packages_config_default,
+  external: () => external,
+  libExternal: () => libExternal
+});
+module.exports = __toCommonJS(external_packages_config_exports);
+var external = ["electron", "electron-updater"];
+var builtins = [
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "zlib"
+];
+var libExternal = ["webpack", "glob"];
+var external_packages_config_default = [...builtins, ...external, ...libExternal];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  builtins,
+  external,
+  libExternal
+});

package/lib/index.js

@@ -0,0 +1,254 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_utils = require("@umijs/utils");
+var path = __toESM(require("path"));
+var import_yargs = __toESM(require("yargs"));
+var import_compile = require("./compile");
+var import_external_packages = __toESM(require("./external-packages.config"));
+var import_setup = __toESM(require("./setup"));
+var import_utils2 = require("./utils");
+var defaultConfig = {
+  buildType: "vite",
+  parallelBuild: false,
+  mainSrc: "src/main",
+  preloadSrc: "src/preload",
+  builderOptions: {},
+  externals: [],
+  outputDir: "dist_electron",
+  routerMode: "hash",
+  rendererTarget: "web",
+  debugPort: 5858,
+  preloadEntry: {
+    "index.ts": "preload.js"
+  },
+  viteConfig: () => {
+  },
+  mainWebpackChain: () => {
+  },
+  logProcess: (log, type) => {
+    if (type === "normal") {
+      (0, import_utils2.logProcess)("Main", log, import_utils.chalk.blue);
+    } else if (type === "error") {
+      (0, import_utils2.logProcess)("Main", log, import_utils.chalk.red);
+    }
+  }
+};
+function src_default(api) {
+  var _a;
+  (0, import_setup.default)(api);
+  api.describe({
+    key: "electronBuilder",
+    config: {
+      default: defaultConfig,
+      schema({ zod }) {
+        return zod.object({
+          buildType: zod.enum(["vite", "webpack"]).optional(),
+          parallelBuild: zod.boolean().optional(),
+          mainSrc: zod.string().optional(),
+          preloadSrc: zod.string().optional(),
+          outputDir: zod.string().optional(),
+          externals: zod.string().array().optional(),
+          builderOptions: zod.record(zod.string(), zod.any()).optional(),
+          routerMode: zod.enum(["hash", "memory", "browser"]).optional(),
+          rendererTarget: zod.enum(["electron-renderer", "web"]).optional(),
+          debugPort: zod.number().optional(),
+          preloadEntry: zod.record(zod.string(), zod.string()).optional(),
+          viteConfig: zod.function().args(zod.any(), zod.enum(["main", "preload"])).returns(zod.void()).optional(),
+          mainWebpackChain: zod.function().args(zod.any(), zod.enum(["main", "preload"])).returns(zod.void()).optional(),
+          logProcess: zod.function().args(zod.string(), zod.enum(["normal", "error"])).returns(zod.void()).optional()
+        });
+      }
+    }
+  });
+  api.registerCommand({
+    name: "electron",
+    fn({ args }) {
+      const arg = args._[0];
+      if (arg === "init") {
+        copyMainProcess();
+      }
+    }
+  });
+  const isElectron = ((_a = api.args) == null ? void 0 : _a._[0]) === "electron";
+  if (!isElectron) {
+    return;
+  }
+  api.modifyConfig((oldConfig) => {
+    const config = import_utils.lodash.merge({ electronBuilder: defaultConfig }, oldConfig);
+    const { outputDir, externals, routerMode } = config.electronBuilder;
+    config.outputPath = process.env.APP_ROOT ? path.join("../..", outputDir, "bundled") : path.join(outputDir, "bundled");
+    config.alias = config.alias || {};
+    config.alias["@/common"] = path.join(process.cwd(), "src/common");
+    config.history = config.history || {
+      type: routerMode
+    };
+    config.history.type = routerMode;
+    const configExternals = {
+      electron: `require('electron')`
+    };
+    if (externals.length > 0) {
+      for (const moduleName of externals) {
+        configExternals[moduleName] = `require('${moduleName}')`;
+      }
+    }
+    config.externals = { ...configExternals, ...config.externals };
+    return config;
+  });
+  api.chainWebpack((config) => {
+    const { rendererTarget } = api.config.electronBuilder;
+    config.target(rendererTarget);
+    if (process.env.PROGRESS !== "none") {
+    }
+    return config;
+  });
+  api.onStart(() => {
+    const { parallelBuild } = api.config.electronBuilder;
+    if (parallelBuild) {
+      (0, import_compile.runBuild)(api).catch((error) => {
+        console.error(error);
+      });
+    }
+  });
+  api.onDevCompileDone(({ isFirstCompile }) => {
+    if (isFirstCompile) {
+      (0, import_compile.runDev)(api).catch((error) => {
+        console.error(error);
+      });
+    }
+  });
+  api.onBuildComplete(({ err }) => {
+    const { parallelBuild } = api.config.electronBuilder;
+    if (err == null) {
+      if (parallelBuild) {
+        buildDist();
+      } else {
+        (0, import_compile.runBuild)(api).then(buildDist).catch((error) => {
+          console.error(error);
+        });
+      }
+    }
+  });
+  function buildDist() {
+    var _a2;
+    const { builderOptions, externals } = api.config.electronBuilder;
+    const absOutputDir = (0, import_utils2.getAbsOutputDir)(api);
+    const buildPkg = (0, import_utils2.getRootPkg)();
+    buildPkg.main = "main.js";
+    delete buildPkg.scripts;
+    delete buildPkg.devDependencies;
+    Object.keys(buildPkg.dependencies).forEach((dependency) => {
+      if (!externals.includes(dependency) && !import_external_packages.default.includes(dependency)) {
+        delete buildPkg.dependencies[dependency];
+      }
+    });
+    externals.forEach((external) => {
+      var _a3;
+      if (!buildPkg.dependencies[external]) {
+        buildPkg.dependencies[external] = (_a3 = require(path.join(
+          process.cwd(),
+          "node_modules",
+          external,
+          "package.json"
+        ))) == null ? void 0 : _a3.version;
+      }
+    });
+    const buildDependencies = [];
+    for (const dep of buildDependencies) {
+      const depPackageJsonPath = path.join(
+        (0, import_utils2.getNodeModulesPath)(),
+        dep,
+        "package.json"
+      );
+      if (import_utils.fsExtra.existsSync(depPackageJsonPath)) {
+        buildPkg.dependencies[dep] = require(depPackageJsonPath).version;
+      } else {
+        buildPkg.dependencies[dep] = (_a2 = require(path.join(
+          process.cwd(),
+          "node_modules",
+          dep,
+          "package.json"
+        ))) == null ? void 0 : _a2.version;
+      }
+    }
+    const buildDir = (0, import_utils2.getBuildDir)(api);
+    import_utils.fsExtra.copySync(buildDir, (0, import_utils2.getBundledDir)(api), { overwrite: true });
+    import_utils.fsExtra.rmSync(buildDir, { recursive: true, force: true });
+    import_utils.fsExtra.ensureDirSync(`${absOutputDir}/bundled/node_modules`);
+    import_utils.fsExtra.writeFileSync(
+      `${absOutputDir}/bundled/package.json`,
+      JSON.stringify(buildPkg, null, 2)
+    );
+    const defaultBuildConfig = {
+      directories: {
+        output: absOutputDir,
+        app: `${absOutputDir}/bundled`
+      },
+      files: ["**"],
+      extends: null
+    };
+    api.logger.info("build electron");
+    const { configureBuildCommand } = require("electron-builder/out/builder");
+    const builderArgs = (0, import_yargs.default)().command(["build", "*"], "Build", configureBuildCommand).parse(process.argv);
+    require("electron-builder").build(
+      import_utils.lodash.merge({
+        config: import_utils.lodash.merge(defaultBuildConfig, builderOptions),
+        ...builderArgs
+      })
+    ).then(() => {
+      api.logger.info("build electron success");
+      process.exit();
+    });
+  }
+  function copyMainProcess() {
+    const mainSrc = (0, import_utils2.getMainSrc)(api);
+    if (!import_utils.fsExtra.pathExistsSync(mainSrc)) {
+      import_utils.fsExtra.copySync(
+        path.join(__dirname, "..", "template", "main"),
+        mainSrc,
+        {
+          overwrite: true
+        }
+      );
+    }
+    const preloadSrc = (0, import_utils2.getPreloadSrc)(api);
+    if (!import_utils.fsExtra.pathExistsSync(preloadSrc)) {
+      import_utils.fsExtra.copySync(
+        path.join(__dirname, "..", "template", "preload"),
+        preloadSrc,
+        { overwrite: true }
+      );
+    }
+  }
+}

package/lib/setup.js

@@ -0,0 +1,105 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  default: () => setup_default
+});
+module.exports = __toCommonJS(setup_exports);
+var import_utils = require("@umijs/utils");
+var import_path = __toESM(require("path"));
+var import_utils2 = require("./utils");
+var setup_default = (api) => {
+  (0, import_utils2.setNpmClient)(api.userConfig.npmClient);
+  const nodeModulesPath = (0, import_utils2.getNodeModulesPath)();
+  let rootPkg = (0, import_utils2.getRootPkg)();
+  const requiredDependencies = ["electron", "electron-builder"];
+  const installDependencies = [];
+  for (const dep of requiredDependencies) {
+    if (rootPkg.devDependencies[dep] == null) {
+      installDependencies.push(dep);
+    }
+  }
+  if (installDependencies.length > 0) {
+    (0, import_utils2.installRely)(installDependencies.join(" "));
+  }
+  rootPkg = (0, import_utils2.getRootPkg)();
+  const electronPackageJson = import_utils.fsExtra.readJSONSync(
+    import_path.default.join(nodeModulesPath, "electron", "package.json")
+  );
+  if (electronPackageJson.dependencies["@types/node"] !== rootPkg.devDependencies["@types/node"]) {
+    const electronTypesNodeVersion = electronPackageJson.dependencies["@types/node"];
+    (0, import_utils2.installRely)(`@types/node@${electronTypesNodeVersion}`);
+  }
+  rootPkg = (0, import_utils2.getRootPkg)();
+  let isUpdateRootPkg = false;
+  if (rootPkg.name == null) {
+    rootPkg.name = "electron_builder_app";
+    isUpdateRootPkg = true;
+  }
+  if (rootPkg.version == null) {
+    rootPkg.version = "0.0.1";
+    isUpdateRootPkg = true;
+  }
+  if (rootPkg.scripts["rebuild-deps"] == null) {
+    rootPkg.scripts["rebuild-deps"] = "electron-builder install-app-deps";
+    isUpdateRootPkg = true;
+  }
+  if (rootPkg.scripts["electron:init"] == null) {
+    rootPkg.scripts["electron:init"] = "umi electron init";
+    isUpdateRootPkg = true;
+  }
+  if (rootPkg.scripts["electron:dev"] == null) {
+    rootPkg.scripts["electron:dev"] = "umi dev electron";
+    isUpdateRootPkg = true;
+  }
+  if (rootPkg.scripts["electron:dir"] == null) {
+    rootPkg.scripts["electron:dir"] = "umi build electron --dir";
+    isUpdateRootPkg = true;
+  }
+  if (rootPkg.scripts["electron:build:win"] == null) {
+    rootPkg.scripts["electron:build:win"] = "umi build electron --win";
+    isUpdateRootPkg = true;
+  }
+  if (rootPkg.scripts["electron:build:mac"] == null) {
+    rootPkg.scripts["electron:build:mac"] = "umi build electron --mac";
+    isUpdateRootPkg = true;
+  }
+  if (rootPkg.scripts["electron:build:linux"] == null) {
+    rootPkg.scripts["electron:build:linux"] = "umi build electron --linux";
+    isUpdateRootPkg = true;
+  }
+  if (isUpdateRootPkg) {
+    api.logger.info("update package.json");
+    import_utils.fsExtra.writeFileSync(
+      import_path.default.join(process.cwd(), "package.json"),
+      JSON.stringify(rootPkg, null, 2)
+    );
+  }
+};

package/lib/types/index.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/types/index.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/utils/index.js

@@ -0,0 +1,174 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  debounce: () => debounce,
+  filterText: () => filterText,
+  getAbsOutputDir: () => getAbsOutputDir,
+  getBuildDir: () => getBuildDir,
+  getBundledDir: () => getBundledDir,
+  getDevBuildDir: () => getDevBuildDir,
+  getMainSrc: () => getMainSrc,
+  getNodeModulesPath: () => getNodeModulesPath,
+  getPreloadSrc: () => getPreloadSrc,
+  getRootPkg: () => getRootPkg,
+  installRely: () => installRely,
+  logError: () => logError,
+  logProcess: () => logProcess,
+  setNpmClient: () => setNpmClient
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils = require("@umijs/utils");
+var import_path = __toESM(require("path"));
+var npmClient = "pnpm";
+function setNpmClient(_npmClient) {
+  if (_npmClient != null && _npmClient != "") {
+    npmClient = _npmClient;
+  }
+}
+function debounce(f, ms) {
+  let isCoolDown = false;
+  return () => {
+    if (isCoolDown)
+      return;
+    f();
+    isCoolDown = true;
+    setTimeout(() => isCoolDown = false, ms);
+  };
+}
+function installRely(pkgName) {
+  const commandOpts = {
+    cwd: process.cwd(),
+    cleanup: true,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: {
+      FORCE_COLOR: "true"
+    }
+  };
+  switch (npmClient) {
+    case "pnpm":
+      import_utils.execa.execaCommandSync(`pnpm i ${pkgName} --save-dev`, commandOpts);
+      break;
+    case "npm":
+      import_utils.execa.execaCommandSync(`npm i ${pkgName} --save-dev`, commandOpts);
+      break;
+    case "yarn":
+      import_utils.execa.execaCommandSync(`yarn add ${pkgName} --dev`, commandOpts);
+      break;
+    default:
+      import_utils.execa.execaCommandSync(`pnpm i ${pkgName} --save-dev`, commandOpts);
+      break;
+  }
+}
+function getRootPkg() {
+  const pkg = import_utils.fsExtra.readJSONSync(import_path.default.join(process.cwd(), "package.json"));
+  if (pkg.devDependencies == null) {
+    pkg.devDependencies = {};
+  }
+  return pkg;
+}
+function getNodeModulesPath() {
+  return import_path.default.join(process.cwd(), "node_modules");
+}
+function getMainSrc(api) {
+  const { mainSrc } = api.config.electronBuilder;
+  return import_path.default.join(process.cwd(), mainSrc);
+}
+function getPreloadSrc(api) {
+  const { preloadSrc } = api.config.electronBuilder;
+  return import_path.default.join(process.cwd(), preloadSrc);
+}
+function getDevBuildDir(api) {
+  return import_path.default.join(api.paths.absTmpPath, "electron");
+}
+function getBuildDir(api) {
+  return import_path.default.join(getAbsOutputDir(api), "electron");
+}
+function getBundledDir(api) {
+  return import_path.default.join(getAbsOutputDir(api), "bundled");
+}
+function getAbsOutputDir(api) {
+  const { outputDir } = api.config.electronBuilder;
+  return import_path.default.join(process.cwd(), outputDir);
+}
+function filterText(s) {
+  const lines = s.trim().split(/\r?\n/).filter((it) => {
+    if (it.includes("Couldn't set selectedTextBackgroundColor from default ()")) {
+      return false;
+    }
+    if (it.includes("Use NSWindow's -titlebarAppearsTransparent=YES instead.")) {
+      return false;
+    }
+    if (it.includes("Debugger listening on")) {
+      return false;
+    }
+    return !it.includes(
+      "Warning: This is an experimental feature and could change at any time."
+    ) && !it.includes("No type errors found") && !it.includes("webpack: Compiled successfully.");
+  });
+  if (lines.length === 0) {
+    return null;
+  }
+  return "  " + lines.join(`
+  `) + "\n";
+}
+function logError(label, error) {
+  logProcess(label, error.stack || error.toString(), import_utils.chalk.red);
+}
+function logProcess(label, log, labelColor) {
+  const LABEL_LENGTH = 28;
+  if (log == null || log.length === 0 || log.trim().length === 0) {
+    return;
+  }
+  process.stdout.write(
+    labelColor.bold(
+      `┏ ${label} ${"-".repeat(LABEL_LENGTH - label.length - 1)}`
+    ) + "\n\n" + log + "\n" + labelColor.bold(`┗ ${"-".repeat(LABEL_LENGTH)}`) + "\n"
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debounce,
+  filterText,
+  getAbsOutputDir,
+  getBuildDir,
+  getBundledDir,
+  getDevBuildDir,
+  getMainSrc,
+  getNodeModulesPath,
+  getPreloadSrc,
+  getRootPkg,
+  installRely,
+  logError,
+  logProcess,
+  setNpmClient
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "akey-umi-plugin-electron-builder",
+  "version": "4.0.9",
+  "description": "Umi plugin for electron-builder",
+  "main": "lib/index.js",
+  "scripts": {
+    "dev": "father dev",
+    "build": "father build",
+    "build:deps": "father prebundle",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "lib",
+    "template"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BySlin/umi-plugin-electron-builder"
+  },
+  "keywords": [
+    "umi"
+  ],
+  "authors": [
+    "BySlin <2292735470@qq.com>"
+  ],
+  "license": "MIT",
+  "bugs": "https://github.com/BySlin/umi-plugin-electron-builder/issues",
+  "homepage": "https://github.com/BySlin/umi-plugin-electron-builder/tree/master#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@umijs/bundler-webpack": "latest",
+    "@umijs/utils": "latest",
+    "electron": "latest",
+    "electron-builder": "latest",
+    "ts-loader": "latest",
+    "vite": "latest",
+    "yargs": "latest"
+  },
+  "devDependencies": {
+    "@types/yargs": "latest",
+    "father": "latest",
+    "prettier": "latest",
+    "typescript": "latest",
+    "umi": "latest"
+  }
+}

package/template/main/createProtocol.ts

@@ -0,0 +1,13 @@
+import { protocol } from 'electron';
+import { URL } from 'url';
+import * as path from 'path';
+
+export default (scheme: string) => {
+  protocol.registerFileProtocol(scheme, (request, respond) => {
+    let pathName = new URL(request.url).pathname;
+    pathName = decodeURI(pathName); // Needed in case URL contains spaces
+
+    const filePath = path.join(__dirname, pathName);
+    respond({ path: filePath });
+  });
+};

package/template/main/index.ts

@@ -0,0 +1,51 @@
+import { app, BrowserWindow, protocol } from 'electron';
+import * as path from 'path';
+import createProtocol from './createProtocol';
+
+const isDevelopment = process.env.NODE_ENV === 'development';
+let mainWindow: BrowserWindow;
+
+protocol.registerSchemesAsPrivileged([
+  {
+    scheme: 'app',
+    privileges: {
+      secure: true,
+      standard: true,
+      supportFetchAPI: true,
+      allowServiceWorkers: true,
+    },
+  },
+]);
+
+function createWindow() {
+  mainWindow = new BrowserWindow({
+    width: 800,
+    height: 600,
+    webPreferences: {
+      contextIsolation: true,
+      preload: path.join(__dirname, 'preload.js'),
+    },
+  });
+  if (isDevelopment) {
+    mainWindow.loadURL('http://localhost:8000');
+  } else {
+    createProtocol('app');
+    mainWindow.loadURL('app://./index.html');
+  }
+}
+
+app.on('ready', async () => {
+  createWindow();
+});
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit();
+  }
+});
+
+app.on('activate', () => {
+  if (mainWindow === null) {
+    createWindow();
+  }
+});

package/template/preload/index.ts

@@ -0,0 +1,9 @@
+import { contextBridge } from 'electron';
+
+const apiKey = 'electron';
+
+const api: any = {
+  versions: process.versions,
+};
+
+contextBridge.exposeInMainWorld(apiKey, api);