vue-cli-plugin-electron-haunv 1.0.2 → 1.0.3

package/lib/plugin.js

@@ -1,40 +0,0 @@
-'use strict'
-
-/**
- * Vite plugin for Electron development (electron:serve)
- * @param {object} options
- * @returns {import('vite').Plugin}
- */
-function electronServePlugin(options = {}) {
-  return {
-    name: 'vite-plugin-electron-builder:serve',
-    apply: 'serve',
-    async configureServer(server) {
-      server.httpServer?.once('listening', async () => {
-        const address = server.httpServer?.address()
-        const port = typeof address === 'object' ? address?.port : 8080
-        process.env.VITE_DEV_SERVER_URL = `http://localhost:${port}`
-        const { serve } = require('./serve')
-        await serve(options)
-      })
-    },
-  }
-}
-
-/**
- * Vite plugin for Electron production build (electron:build)
- * @param {object} options
- * @returns {import('vite').Plugin}
- */
-function electronBuildPlugin(options = {}) {
-  return {
-    name: 'vite-plugin-electron-builder:build',
-    apply: 'build',
-    async closeBundle() {
-      const { buildMain } = require('./build')
-      await buildMain(options)
-    },
-  }
-}
-
-module.exports = { electronServePlugin, electronBuildPlugin }

package/lib/protocol.js

@@ -1,55 +0,0 @@
-'use strict'
-
-/**
- * Create a secure custom protocol handler for Electron.
- *
- * This registers a custom file:// protocol (e.g. app://) that serves
- * renderer files without path traversal vulnerabilities.
- *
- * Usage in your background.js (main process):
- *
- *   import { createProtocol } from 'vite-plugin-electron-builder/lib/protocol'
- *
- *   app.whenReady().then(() => {
- *     createProtocol('app')
- *     win.loadURL('app://./index.html')
- *   })
- *
- * @param {string} scheme - The protocol name, e.g. 'app'
- * @param {string} [customPathToFiles] - Override path to bundled renderer files
- */
-function createProtocol(scheme, customPathToFiles) {
-  const { protocol } = require('electron')
-  const path = require('path')
-  const fs = require('fs')
-  const { URL } = require('url')
-
-  // Determine the base path for renderer files
-  const basePath = customPathToFiles
-    ? path.resolve(customPathToFiles)
-    : path.resolve(__dirname, '..', 'bundled')
-
-  protocol.registerFileProtocol(scheme, (request, callback) => {
-    // Parse the URL and get the pathname
-    const url = new URL(request.url)
-    // Decode URI and normalize the path
-    const decodedPath = decodeURIComponent(url.pathname)
-    // Resolve to absolute path within basePath (prevents traversal)
-    const filePath = path.normalize(path.join(basePath, decodedPath))
-
-    // Security: ensure the resolved path is still inside basePath
-    if (!filePath.startsWith(basePath + path.sep) && filePath !== basePath) {
-      callback({ error: -6 }) // net::ERR_FILE_NOT_FOUND
-      return
-    }
-
-    // Check if file exists, fall back to index.html for SPA routing
-    if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
-      callback({ path: filePath })
-    } else {
-      callback({ path: path.join(basePath, 'index.html') })
-    }
-  })
-}
-
-module.exports = { createProtocol }

package/lib/serve.js

@@ -1,99 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { execa } = require('execa')
-const chokidar = require('chokidar')
-const chalk = require('chalk')
-
-let electronProcess = null
-let manualRestart = false
-
-/**
- * Start Electron in development mode, watching for main process changes.
- * @param {object} options
- * @param {string} [options.mainProcessFile] - path to compiled main process entry (default: 'dist-electron/main.js')
- * @param {string[]} [options.mainProcessWatch] - extra globs to watch for restarts
- * @param {string} [options.outputDir] - output directory for compiled main process (default: 'dist_electron')
- */
-async function serve(options = {}) {
-  const outputDir = options.outputDir || 'dist_electron'
-  const mainFile = options.mainProcessFile || path.join(outputDir, 'main.js')
-
-  await compileMain(options)
-  startElectron(mainFile)
-
-  // Watch main process source files
-  const watchPatterns = options.mainProcessWatch || [
-    path.join(process.cwd(), 'src/main/**/*.{js,ts}'),
-    path.join(process.cwd(), 'src/background.{js,ts}'),
-    path.join(process.cwd(), 'src/preload/**/*.{js,ts}'),
-  ]
-
-  const watcher = chokidar.watch(watchPatterns, {
-    ignoreInitial: true,
-    ignored: /node_modules/,
-  })
-
-  watcher.on('change', async (file) => {
-    console.log(chalk.blue(`[electron-builder] Main process changed: ${file}`))
-    console.log(chalk.blue('[electron-builder] Recompiling...'))
-    await compileMain(options)
-    restartElectron(mainFile)
-  })
-}
-
-/**
- * Compile the Electron main process using esbuild (via electron-builder internals or standalone)
- */
-async function compileMain(options = {}) {
-  const { buildMain } = require('./build')
-  try {
-    await buildMain({ ...options, mode: 'development' })
-    console.log(chalk.green('[electron-builder] Main process compiled successfully'))
-  } catch (err) {
-    console.error(chalk.red('[electron-builder] Main process compilation failed:'), err.message)
-  }
-}
-
-/**
- * Launch the Electron process
- */
-function startElectron(mainFile) {
-  const electronBin = require('electron')
-  electronProcess = execa(String(electronBin), [mainFile], {
-    stdio: 'inherit',
-    env: {
-      ...process.env,
-      NODE_ENV: 'development',
-    },
-  })
-
-  electronProcess.on('close', (code) => {
-    if (!manualRestart) {
-      console.log(chalk.yellow(`[electron-builder] Electron exited with code ${code}`))
-      process.exit(code ?? 0)
-    }
-    manualRestart = false
-  })
-
-  electronProcess.catch((err) => {
-    if (!err.killed) {
-      console.error(chalk.red('[electron-builder] Electron process error:'), err)
-    }
-  })
-}
-
-/**
- * Kill and restart the Electron process
- */
-function restartElectron(mainFile) {
-  if (electronProcess) {
-    manualRestart = true
-    electronProcess.kill()
-    electronProcess = null
-  }
-  console.log(chalk.green('[electron-builder] Restarting Electron...'))
-  startElectron(mainFile)
-}
-
-module.exports = { serve }

package/lib/vitePlugin.js

@@ -1,65 +0,0 @@
-'use strict'
-
-const path = require('path')
-const fs = require('fs-extra')
-const { buildMain } = require('./build')
-const { getConfig } = require('./config')
-const chalk = require('chalk')
-
-/**
- * Creates the Vite plugin that integrates Electron into the Vite dev/build pipeline.
- * This is the primary export — add it to your vite.config.js plugins array.
- *
- * @param {import('..').ElectronBuilderOptions} pluginOptions
- * @returns {import('vite').Plugin}
- */
-function createElectronPlugin(pluginOptions = {}) {
-  const options = getConfig(pluginOptions)
-
-  return {
-    name: 'vite-plugin-electron-builder',
-
-    /**
-     * Adjust base path so Electron can load the renderer via file:// or app:// protocol.
-     */
-    config(config, { command }) {
-      if (command === 'serve') {
-        return {
-          base: './',
-          server: { ...config.server },
-        }
-      }
-      return {
-        base: './',
-        build: {
-          outDir: path.join(options.outputDir, 'bundled'),
-          ...config.build,
-        },
-      }
-    },
-
-    /**
-     * Warn early if the main process entry file is missing.
-     */
-    async buildStart() {
-      const mainFile = path.resolve(process.cwd(), options.mainProcessFile)
-      if (!fs.existsSync(mainFile)) {
-        this.warn(
-          `[electron-builder] Main process file not found: ${mainFile}. ` +
-          `Set mainProcessFile in createElectronPlugin options.`
-        )
-      }
-    },
-
-    /**
-     * After the renderer bundle is emitted, compile the main process with esbuild.
-     */
-    async closeBundle() {
-      console.log(chalk.cyan('\n[electron-builder] Compiling main process...'))
-      await buildMain(options)
-      console.log(chalk.green('[electron-builder] Main process compiled.\n'))
-    },
-  }
-}
-
-module.exports = { createElectronPlugin }