add root support

Author: subframe7536

package.json

@@ -60,7 +60,7 @@
   "scripts": {
     "dev": "tsdown --watch",
     "build": "tsdown",
-    "play": "cd ./playground && vite",
+    "play": "vite",
     "release": "bun run format && bun run lint && bun run test && bun run build && bumpp --all",
     "test": "bun test",
     "test:dev": "bun test --watch",

src/vite/core.ts

@@ -18,7 +18,7 @@ import { bytecodePlugin } from './bytecode'
 import { id, log } from './constant'
 import electron from './electron/core'
 import { notBundle } from './electron/plugin'
-import { parseOptions } from './option'
+import { parseUpdaterOption } from './option'
 import { copyAndSkipIfExist } from './utils'
 
 export interface ElectronSimpleOptions {
@@ -202,14 +202,10 @@ const defaultExternal = [
 export async function electronWithUpdater(
   options: ElectronWithUpdaterOptions,
 ): Promise<PluginOption[] | undefined> {
-  const pkg = await loadPackageJSON()
-  if (!pkg || !pkg.version || !pkg.name || !pkg.main) {
-    throw new Error('package.json not found or invalid, must contains version, name and main field')
-  }
-
   let {
     isBuild,
-    external = Object.keys(pkg.dependencies || {}),
+    root = process.cwd(),
+    external,
     entry: _entry,
     main: _main,
     preload: _preload,
@@ -221,9 +217,16 @@ export async function electronWithUpdater(
     useNotBundle = true,
   } = options
 
-  log.info(`Clear cache files`, { timestamp: true })
+  const pkg = await loadPackageJSON(root)
+  if (!pkg || !pkg.version || !pkg.name || !pkg.main) {
+    throw new Error('package.json not found or invalid, must contains version, name and main field')
+  }
+
   const isESM = pkg.type === 'module'
-  const finalExternal = [...defaultExternal, ...(isBuild || _entry.postBuild ? [] : external)]
+  const finalExternal = [
+    ...defaultExternal,
+    ...(isBuild || _entry.postBuild ? [] : external || Object.keys(pkg.dependencies || {})),
+  ]
 
   let bytecodeOptions =
     typeof bytecode === 'object' ? bytecode : bytecode === true ? { enable: true } : undefined
@@ -234,15 +237,16 @@ export async function electronWithUpdater(
     )
   }
 
-  const { buildAsarOption, buildVersionOption, cert, entryOutDir } = await parseOptions(
+  const { buildAsarOption, buildVersionOption, cert, entryOutDir } = await parseUpdaterOption(
     pkg as PKG,
     updater,
   )
 
-  try {
-    fs.rmSync(buildAsarOption.electronDistPath, { recursive: true, force: true })
-    fs.rmSync(entryOutDir, { recursive: true, force: true })
-  } catch {}
+  log.info(`Clear cache files`, { timestamp: true })
+  await Promise.all([
+    fs.promises.rm(buildAsarOption.electronDistPath, { recursive: true, force: true }),
+    fs.promises.rm(entryOutDir, { recursive: true, force: true }),
+  ]).catch(() => {})
 
   const define = {
     __EIU_ASAR_BASE_NAME__: JSON.stringify(path.basename(buildAsarOption.asarOutputPath)),
@@ -261,7 +265,7 @@ export async function electronWithUpdater(
   const _electronOptions: ElectronOptions[] = [
     {
       entry: _main.files,
-      onstart: _main.onstart || ((args) => args.startup()),
+      onstart: _main.onstart,
       vite: mergeConfig(
         {
           plugins: [
@@ -397,5 +401,5 @@ export async function electronWithUpdater(
     ),
   })
 
-  return electron(isESM, _electronOptions)
+  return electron(isESM, normalizePath(path.resolve(root)), _electronOptions)
 }

src/vite/define.ts

@@ -1,4 +1,4 @@
-import type { UserConfig, UserConfigFn } from 'vite'
+import type { InlineConfig, UserConfig, UserConfigFn } from 'vite'
 
 import type { ElectronWithUpdaterOptions } from './option'
 
@@ -13,7 +13,7 @@ export interface ElectronViteHelperOptions extends MakeOptional<
   /**
    * Config for renderer process
    */
-  renderer?: UserConfig
+  renderer?: Omit<UserConfig, 'root'>
 }
 
 /**
@@ -54,6 +54,7 @@ export function defineElectronConfig(options: ElectronViteHelperOptions): UserCo
     const result = options.renderer ?? {}
     result.plugins ??= []
     result.plugins.push(electronPlugin)
+    ;(result as InlineConfig).root = options.root
     const rendererDistPath = options.updater?.paths?.rendererDistPath
     if (rendererDistPath) {
       result.build ??= {}

src/vite/electron/core.ts

@@ -21,9 +21,9 @@ export interface ElectronOptions {
     /**
      * Electron App startup function.
      * It will mount the Electron App child-process to `process.electronApp`.
-     * @param argv default value `['.', '--no-sandbox']`
-     * @param options options for `child_process.spawn`
-     * @param customElectronPkg custom electron package name (default: 'electron')
+     * - argv: electron startup arguments (default `['.', '--no-sandbox']`)
+     * - options: options for `child_process.spawn`
+     * - customElectronPkg: custom electron package name (default: `'electron'`)
      */
     startup: (argv?: string[], options?: SpawnOptions, customElectronPkg?: string) => Promise<void>
     /** Reload Electron-Renderer */
@@ -37,6 +37,7 @@ export function build(isESM: boolean, options: ElectronOptions): ReturnType<type
 
 export default function electron(
   isESM: boolean,
+  root: string,
   options: ElectronOptions | ElectronOptions[],
 ): Plugin[] {
   const optionsArray = Array.isArray(options) ? options : [options]
@@ -57,6 +58,13 @@ export default function electron(
     {
       name: 'vite-plugin-electron:dev',
       apply: 'serve',
+      configResolved(config) {
+        if (config.root !== root) {
+          throw new Error(
+            `Renderer's root (${config.root}) is not same as electron's root (${root}). Please setup \`root\` in electron plugin`,
+          )
+        }
+      },
       configureServer(server) {
         server.httpServer?.once('listening', () => {
           Object.assign(process.env, {
@@ -72,6 +80,7 @@ export default function electron(
             options.vite.root ??= server.config.root
             options.vite.envDir ??= server.config.envDir
             options.vite.envPrefix ??= server.config.envPrefix
+            const defaultArgs = [options.vite.root || '.', '--no-sandbox']
 
             options.vite.build ??= {}
             if (!Object.keys(options.vite.build).includes('watch')) {
@@ -87,10 +96,11 @@ export default function electron(
                 if (++closeBundleCount < entryCount) {
                   return
                 }
-
                 if (options.onstart) {
                   options.onstart.call(this, {
-                    startup,
+                    async startup(args = defaultArgs, ...opt) {
+                      await startup(args, ...opt)
+                    },
                     // Why not use Vite's built-in `/@vite/client` to implement Hot reload?
                     // Because Vite only inserts `/@vite/client` into the `*.html` entry file, the preload scripts are usually a `*.js` file.
                     // @see - https://github.com/vitejs/vite/blob/v5.2.11/packages/vite/src/node/server/middlewares/indexHtml.ts#L399
@@ -101,12 +111,12 @@ export default function electron(
                         // For Electron apps that don't need to use the renderer process.
                         startup.send('electron-vite&type=hot-reload')
                       } else {
-                        startup()
+                        startup(defaultArgs)
                       }
                     },
                   })
                 } else {
-                  startup()
+                  startup(defaultArgs)
                 }
               },
             })
@@ -143,7 +153,7 @@ export default function electron(
 }
 
 interface StartupFn {
-  (): Promise<void>
+  (argv?: string[], options?: SpawnOptions, customElectronPkg?: string): Promise<void>
   send: (message: string) => void
   hookedProcessExit: boolean
   exit: () => Promise<void>
@@ -158,8 +168,8 @@ interface StartupFn {
  */
 export const startup: StartupFn = async (
   argv = ['.', '--no-sandbox'],
-  options?: SpawnOptions,
-  customElectronPkg?: string,
+  options?,
+  customElectronPkg?,
 ) => {
   const { spawn } = await import('node:child_process')
   const electron = await import(customElectronPkg ?? 'electron')

src/vite/option.ts

@@ -50,6 +50,12 @@ export interface ElectronWithUpdaterOptions {
    * ```
    */
   isBuild: boolean
+  /**
+   * Project root directory. Can be an absolute path, or a path relative from
+   * the location of the config file itself.
+   * @default process.cwd()
+   */
+  root?: string
   /**
    * Whether to generate sourcemap
    * @default !isBuild || !!process.env.VSCODE_DEBUG
@@ -318,7 +324,7 @@ interface ParseOptionReturn {
   entryOutDir: string
 }
 
-export async function parseOptions(
+export async function parseUpdaterOption(
   pkg: PKG,
   options: UpdaterOptions = {},
 ): Promise<ParseOptionReturn> {

tsconfig.json

@@ -1,4 +1,4 @@
 {
   "extends": "@subframe7536/type-utils/tsconfig.json",
-  "include": ["src", "tests", "playground"]
+  "include": ["src", "tests", "playground", "vite.config.ts"]
 }

playground/vite.config.ts vite.config.tsplayground/vite.config.ts renamed to vite.config.ts

@@ -1,10 +1,12 @@
-import { defineElectronConfig } from '../src/vite'
+import { defineElectronConfig } from './src/vite'
 
 export default defineElectronConfig({
+  root: './playground',
   entry: { files: ['./entry.ts', './native.ts'] },
-  main: { files: './main.ts' },
+  main: {
+    files: './main.ts',
+  },
   // preload: { files: './preload.ts' },
-  // todo)) new `root` in top level. create package.json if not exist
   renderer: {},
   updater: {},
 })