[WIP] feat: electron plugin

packages/plugin-electron/.npmrc

@@ -0,0 +1,2 @@
+electron-mirror=https://npm.taobao.org/mirrors/electron/
+electron-builder-binaries-mirror=http://npm.taobao.org/mirrors/electron-builder-binaries/

packages/plugin-electron/README.md

@@ -0,0 +1,19 @@
+# @umijs/plugin-electron
+
+> @umijs/plugin-electron.
+
+See our website [@umijs/plugin-electron](https://umijs.org/plugins/plugin-electron) for more information.
+
+## Install
+
+Using npm:
+
+```bash
+$ npm install --save-dev @umijs/plugin-electron
+```
+
+or using yarn:
+
+```bash
+$ yarn add @umijs/plugin-electron --dev
+```

packages/plugin-electron/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@umijs/plugin-electron",
+  "version": "0.1.0-0",
+  "description": "@umijs/plugin-electron",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/umijs/plugins"
+  },
+  "keywords": [
+    "umi"
+  ],
+  "authors": [
+    "xiefengnian <[email protected]> (https://github.com/xiefengnian)"
+  ],
+  "license": "MIT",
+  "bugs": "http://github.com/umijs/plugins/issues",
+  "homepage": "https://github.com/umijs/plugins/tree/master/packages/plugin-dva#readme",
+  "peerDependencies": {
+    "umi": "3.x"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "father-build" : "1.20.5-5",
+    "electron" : "^14",
+    "electron-builder": "22.10.5",
+    "babel-plugin-import-to-window-require" : "*",
+    "rimraf": "^3.0.2"
+  },
+  "devDependencies": {
+    "@types/rimraf": "^3.0.2"
+  }
+}

packages/plugin-electron/src/buildElectron.ts

@@ -0,0 +1,50 @@
+import { rimraf } from '@umijs/utils';
+import {
+  build,
+  Platform,
+  createTargets,
+  Configuration,
+} from 'electron-builder';
+import lodash from 'lodash';
+import { join } from 'path';
+import { generateMd5 } from './utils';
+
+const builderConfig = require('./config/electron-builder.config');
+export const buildElectron = (customBuilderConfig?: Configuration) => {
+  rimraf.sync(join(process.cwd(), 'dist'));
+
+  const targets =
+    process.platform === 'darwin'
+      ? [Platform.MAC, Platform.WINDOWS]
+      : [Platform.WINDOWS];
+
+  build({
+    targets: createTargets(targets),
+    config: lodash.merge(
+      customBuilderConfig || {},
+      builderConfig as unknown as Configuration,
+      {
+        electronVersion: '14.0.0',
+        directories: { output: 'dist' },
+      } as Configuration,
+      {
+        dmg: {
+          title: `\${productName}-\${version}`,
+          artifactName: `\${productName}-\${version}.\${ext}`,
+        },
+        nsis: {
+          artifactName: `\${productName}-setup-\${version}.\${ext}`,
+        },
+      } as Configuration,
+    ),
+  })
+    .then((res) => {
+      generateMd5(res);
+    })
+    .catch((err) => {
+      console.log(err);
+    })
+    .finally(() => {
+      process.send?.('exit');
+    });
+};

packages/plugin-electron/src/check.ts

@@ -0,0 +1,31 @@
+import { resolve } from 'path';
+import chalk from 'chalk';
+import yParser from 'yargs-parser';
+import { TMP_DIR } from './constants';
+const args = yParser(process.argv.slice(2));
+
+const checkMainField = () => {
+  const userPackageJson = require(resolve(process.cwd(), './package.json'));
+  const { main } = userPackageJson;
+  if (!main) {
+    console.log(
+      chalk.bgRedBright('Error') +
+        ` ${chalk.red('main')} field in package.json must not be empty`,
+    );
+    throw new Error('empty entry');
+  } else {
+    if (!args.output && main !== `${TMP_DIR}/main/index.js`) {
+      console.log(
+        chalk.bgRedBright('Error') +
+          ` ${chalk.red('main')} field in package.json must be ${chalk.red(
+            `"${TMP_DIR}/main/index.js"`,
+          )}`,
+      );
+      throw new Error('wrong entry');
+    }
+  }
+};
+
+export const check = () => {
+  checkMainField();
+};

packages/plugin-electron/src/config/electron-builder.config.js

@@ -0,0 +1,23 @@
+import { join } from 'path';
+
+const { productName } = require(join(process.cwd(), 'package.json'));
+
+module.exports = {
+  electronDownload: {
+    mirror: 'https://npm.taobao.org/mirrors/electron/',
+  },
+  productName,
+  files: ['.electron/**'],
+  mac: {
+    category: 'public.app-category.developer-tools',
+    target: 'dmg',
+  },
+  dmg: {},
+  win: {
+    target: 'nsis',
+  },
+  nsis: {
+    oneClick: false,
+    allowToChangeInstallationDirectory: true,
+  },
+};

packages/plugin-electron/src/config/father.js

@@ -0,0 +1,67 @@
+const { resolve } = require('path');
+const { writeFileSync } = require('fs');
+const { getPkgName } = require('../utils/getPkgName');
+
+const deps = new Set(); // 搜集所有依赖
+const depsOfFile = {}; // 搜集文件依赖
+const filesOfDep = {}; // 搜集依赖所在文件
+/**
+ *
+ * @param {Set} toGenerateDeps
+ */
+const generateDeps = (toGenerateDeps) => {
+  writeFileSync(
+    resolve(process.cwd(), '.electron/dependencies.json'),
+    JSON.stringify(
+      {
+        all: Array.from(toGenerateDeps),
+        files: Object.keys(depsOfFile).reduce((memo, current) => {
+          return {
+            ...memo,
+            [current]: Array.from(depsOfFile[current]),
+          };
+        }, {}),
+        deps: Object.keys(filesOfDep).reduce((memo, current) => {
+          return {
+            ...memo,
+            [current]: Array.from(filesOfDep[current]),
+          };
+        }, {}),
+      },
+      null,
+      2,
+    ),
+  );
+};
+
+export default {
+  entry: resolve(process.cwd(), 'src/main/index.ts'),
+  cjs: {
+    type: 'babel',
+  },
+  target: 'node',
+  disableTypeCheck: true,
+  extraBabelPlugins: [
+    [
+      require('../features/package-analyze/babel-plugin-import-analyze'),
+      {
+        onCollect: (filename, depName) => {
+          let finalDepName = getPkgName(depName);
+          if (!finalDepName) {
+            return;
+          }
+          deps.add(finalDepName);
+          if (!depsOfFile[filename]) {
+            depsOfFile[filename] = new Set();
+          }
+          if (!filesOfDep[finalDepName]) {
+            filesOfDep[finalDepName] = new Set();
+          }
+          filesOfDep[finalDepName].add(filename);
+          depsOfFile[filename].add(finalDepName);
+          generateDeps(deps);
+        },
+      },
+    ],
+  ],
+};

packages/plugin-electron/src/constants.ts

@@ -0,0 +1 @@
+export const TMP_DIR = '.electron';

packages/plugin-electron/src/electronManager.ts

@@ -0,0 +1,43 @@
+import electron from 'electron';
+import proc, { ChildProcess } from 'child_process';
+import { resolve } from 'path';
+import yParser from 'yargs-parser';
+import { log } from './utils';
+const args = yParser(process.argv.slice(2));
+
+const appPath = resolve(process.cwd());
+
+export class ElectronProcessManager {
+  electronProcess: ChildProcess | undefined;
+  start() {
+    this.kill();
+    const childProc = proc.spawn(
+      electron as unknown as string,
+      args.inspect ? [`--inspect=${args.inspect}`, appPath] : [appPath],
+      {
+        stdio: 'pipe',
+        env: {
+          ...process.env,
+          FORCE_COLOR: '1',
+        },
+      },
+    );
+
+    childProc.on('error', (err) => {
+      log.error('electron process error!');
+      console.log(err);
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      childProc.kill();
+      process.exit(1);
+    });
+
+    childProc.stdout?.pipe(process.stdout);
+    childProc.stderr?.pipe(process.stderr);
+
+    this.electronProcess = childProc;
+  }
+
+  kill() {
+    this.electronProcess?.kill();
+  }
+}

packages/plugin-electron/src/fatherCli.ts

@@ -0,0 +1,107 @@
+import { fork } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import path, { resolve, join } from 'path';
+import chokidar from 'chokidar';
+import { debounce } from 'lodash';
+import { TMP_DIR } from './constants';
+import { log } from './utils';
+
+type FatherBuildCliOpts = {
+  configPath?: string;
+  src?: string;
+  output?: string;
+};
+
+export type WatchReturnType = {
+  exit: () => void;
+};
+
+type WatchOpts = {
+  onBuild?: () => void;
+};
+
+class FatherBuildCli {
+  private opts: FatherBuildCliOpts;
+  constructor(opts: FatherBuildCliOpts) {
+    this.opts = {
+      configPath: opts.configPath,
+      src: opts.src || resolve(process.cwd(), 'src', 'main'),
+      output: opts.output || resolve(process.cwd(), TMP_DIR, 'main'),
+    };
+  }
+  watch(opts: WatchOpts): { exit: () => void } {
+    const proc = fork(
+      join(require.resolve('father-build'), '../../bin/father-build.js'),
+      [
+        `--src=${this.opts.src}`,
+        `--output=${this.opts.output}`,
+        '-w',
+        `--config=${this.opts.configPath}`,
+      ],
+      {
+        stdio: 'pipe',
+        env: { ...process.env, FORCE_COLOR: '1' },
+        cwd: process.cwd(),
+      },
+    );
+    proc.stdout?.pipe(process.stdout);
+    proc.stderr?.pipe(process.stderr);
+    const watchDir = join(process.cwd(), TMP_DIR, 'main');
+    const watcher = chokidar.watch(watchDir, { ignoreInitial: true }).on(
+      'all',
+      debounce(() => {
+        opts.onBuild?.();
+      }, 500),
+    );
+    log.info(`watching ${watchDir}`);
+    return {
+      exit: () => {
+        watcher.close().then(() => {
+          proc.kill();
+        });
+      },
+    };
+  }
+  build(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      const args = this.opts.configPath
+        ? [`--config=${this.opts.configPath}`]
+        : [];
+      const proc = fork(
+        join(require.resolve('father-build'), '../../bin/father-build.js'),
+        args.concat([
+          `--output=${this.opts?.output}`,
+          `--src=${this.opts.src}`,
+        ]),
+        {
+          stdio: 'pipe',
+          env: { ...process.env, FORCE_COLOR: '1' },
+        },
+      );
+      proc.stdout?.pipe(process.stdout);
+      proc.stderr?.pipe(process.stderr);
+      const messages: unknown[] = [];
+      proc.on('message', (msg) => {
+        messages.push(msg);
+      });
+      proc.on('close', (code) => {
+        if (code !== 0) {
+          reject(messages.join('\n'));
+        }
+        resolve(true);
+      });
+      proc.on('error', (err) => {
+        throw err;
+      });
+    });
+  }
+  static getUserConfig(): string | undefined {
+    const userConfigPath = path.resolve(process.cwd(), '.fatherrc.js');
+    if (existsSync(userConfigPath)) {
+      return readFileSync(userConfigPath, 'utf-8');
+    }
+    return;
+  }
+}
+
+export { FatherBuildCli };