mirror of
https://github.com/alex8088/electron-vite.git
synced 2026-11-02 22:56:58 +08:00
Compare commits
No commits in common. "master" and "v4.0.0-beta.0" have entirely different histories.
master
...
v4.0.0-bet
148
CHANGELOG.md
148
CHANGELOG.md
@ -1,146 +1,4 @@
|
||||
### v6.0.0 (_2026-10-15_)
|
||||
|
||||
- feat(bytecode): support RegExp for chunkAlias option ([#885](https://github.com/alex8088/electron-vite/issues/885))
|
||||
- refactor: share and normalize build output resolution
|
||||
- refactor: inline bytecode build plugin name
|
||||
- refactor!: invoke the bytecode compiler only once to compile all code
|
||||
- refactor: use pipe stdio for spawn Electron bytecode compliler and append stderr error
|
||||
- refactor: use rolldown instead of esbuild to bundle config file
|
||||
- refactor: compile bytecode using the Electron main process or renderer process rather then via the `ELECTRON_RUN_AS_NODE`
|
||||
- refactor!: simplify resolve config and isolate user config for sub-builds
|
||||
- refactor: `?modulePath` sub-build output strategy
|
||||
- perf(swcPlugin): skip redundant minification when using Oxc ([#922](https://github.com/alex8088/electron-vite/issues/922))
|
||||
- perf: skip Babel loading in development and builds without bytecode
|
||||
- perf: short-circuit bytecode detection in builds
|
||||
- perf: setup rollupOption compatibility via config factory
|
||||
- perf: build compatibility target for Electron 42, 43, 44
|
||||
- fix(asset): use consistent file paths for asset cache lookups
|
||||
- fix(bytecode): unable to obtain the bytecode build session in Node.js 24 ([#928](https://github.com/alex8088/electron-vite/issues/928))
|
||||
- fix(dev): exit non-zero when Electron is killed by a signal ([#918](https://github.com/alex8088/electron-vite/issues/918))
|
||||
- fix(dev): forward termination signals to Electron child ([#900](https://github.com/alex8088/electron-vite/issues/900))
|
||||
- fix(dev): improve Electron process signal handling
|
||||
- fix(bytecode): set the regular expression's `lastIndex` to 0 to perform a global match for chunkAlias option
|
||||
- fix(esmShim)!: use `this.parse` to find the last static import ([#906](https://github.com/alex8088/electron-vite/issues/906))
|
||||
- fix(deps)!: downgraded @babel/* to v7 due to Node requirements
|
||||
- fix: remove useless preset config
|
||||
- fix(swcPlugin): also disable oxc on Vite 8 ([#920](https://github.com/alex8088/electron-vite/issues/920))
|
||||
- fix: clone config without plugins [#902](https://github.com/alex8088/electron-vite/issues/902)
|
||||
- fix(deps)!: update magic-string to v1
|
||||
- fix(deps)!: update @babel/* to v8
|
||||
- fix!: compatible with rollupOptions and rolldownOptions
|
||||
- fix: chunk filename is wrong in ES mode
|
||||
- fix(asset): isolate asset caches per environment
|
||||
- fix: use the environment api in plugins
|
||||
- fix: skip TTY terminal manipulations in CI environments
|
||||
- fix(deps)!: update vite to v8 ([#894](https://github.com/alex8088/electron-vite/issues/894))
|
||||
- fix: Typescript compiler option 'outDir' must be located inside Rollup 'dir' option
|
||||
- fix(isolateEntries): handle non-TTY stdout in build reporter (#887)
|
||||
- chore: simplify bytecode compiler initialization
|
||||
- chore: improve jsdoc for bytecode options ([#898](https://github.com/alex8088/electron-vite/issues/898))
|
||||
- chore(deps): update all non-major dependencies
|
||||
- chore(deps): update lint-staged to v17
|
||||
- chore(deps): update cac to v7
|
||||
- chore(deps): update globals to v17
|
||||
- chore(deps): update eslint and @eslint/js to v10
|
||||
- chore(deps): update all non-major dependencies
|
||||
|
||||
### v6.0.0-beta.8 (_2026-10-11_)
|
||||
|
||||
See [v6.0.0-beta.8 changelog](https://github.com/alex8088/electron-vite/blob/v6.0.0-beta.8/CHANGELOG.md)
|
||||
|
||||
### v6.0.0-beta.7 (_2026-10-08_)
|
||||
|
||||
See [v6.0.0-beta.7 changelog](https://github.com/alex8088/electron-vite/blob/v6.0.0-beta.7/CHANGELOG.md)
|
||||
|
||||
### v6.0.0-beta.6 (_2026-10-07_)
|
||||
|
||||
See [v6.0.0-beta.6 changelog](https://github.com/alex8088/electron-vite/blob/v6.0.0-beta.6/CHANGELOG.md)
|
||||
|
||||
### v6.0.0-beta.5 (_2026-09-29_)
|
||||
|
||||
See [v6.0.0-beta.5 changelog](https://github.com/alex8088/electron-vite/blob/v6.0.0-beta.5/CHANGELOG.md)
|
||||
|
||||
### v6.0.0-beta.4 (_2026-09-28_)
|
||||
|
||||
See [v6.0.0-beta.4 changelog](https://github.com/alex8088/electron-vite/blob/v6.0.0-beta.4/CHANGELOG.md)
|
||||
|
||||
### v6.0.0-beta.3 (_2026-09-27_)
|
||||
|
||||
See [v6.0.0-beta.3 changelog](https://github.com/alex8088/electron-vite/blob/v6.0.0-beta.3/CHANGELOG.md)
|
||||
|
||||
### v6.0.0-beta.2 (_2026-09-27_)
|
||||
|
||||
See [v6.0.0-beta.2 changelog](https://github.com/alex8088/electron-vite/blob/v6.0.0-beta.2/CHANGELOG.md)
|
||||
|
||||
### v6.0.0-beta.1 (_2026-04-12_)
|
||||
|
||||
See [v6.0.0-beta.1 changelog](https://github.com/alex8088/electron-vite/blob/v6.0.0-beta.1/CHANGELOG.md)
|
||||
|
||||
### v6.0.0-beta.0 (_2026-04-09_)
|
||||
|
||||
See [v6.0.0-beta.0 changelog](https://github.com/alex8088/electron-vite/blob/v6.0.0-beta.0/CHANGELOG.md)
|
||||
|
||||
### v5.0.0 (_2025-12-07_)
|
||||
|
||||
- feat(config): add `build.externalizeDeps` and `build.bytecode` config options to replace `externalizeDepsPlugin` and `bytecodePlugin`
|
||||
- feat: reporter plugin for isolated builds
|
||||
- feat: enhanced string protection
|
||||
- feat: add `isolatedEntries` option for `preload` and `renderer` to build entries as standalone bundles [#154](https://github.com/alex8088/electron-vite/issues/154)
|
||||
- refactor(config): move the `isolateEntries` options to the `build` option
|
||||
- refactor: deprecated `externalizeDepsPlugin` and `bytecodePlugin`
|
||||
- refactor(config)!: remove function resolution for nested config fields
|
||||
- refactor(asset): remove redundant path normalization
|
||||
- refactor: split electron plugin into preset and validator plugins
|
||||
- refactor(config)!: restructure Electron Vite config interfaces
|
||||
- refactor(build): simplify build logic
|
||||
- refactor: replace `JSON.parse/stringify` with manual deep clone
|
||||
- refactor(bytecodePlugin): improved bytecode bundle generation and made a new string protection plugin
|
||||
- refactor(modulePath): better support for tree-shaking and code-splitting
|
||||
- refactor: remove Electron 18, 19, 20, 21 build compatilibity target
|
||||
- perf(buildReport): exclude node_modules from watch list
|
||||
- perf(isolateEntries): transform log
|
||||
- perf(isolateEntries): optimize entries transformation
|
||||
- perf: build compatibility target for Electron 39
|
||||
- perf(plugin): more efficient module filtering via regular expressions
|
||||
- perf(plugin): no need to cache `sourcemap` option
|
||||
- perf(plugin): lazily initialize `MagicString` and remove the redundant pre-check
|
||||
- perf(bytecodePlugin): better way to count bytecode chunks
|
||||
- perf(plugin): enhance path resolution using `import.meta.dirname` for ES modules
|
||||
- fix(modulePath): rewrite the build input instead of merging
|
||||
- fix(asset): normalize imported public asset chunk path
|
||||
- fix: avoid duplicate chunk emission
|
||||
- fix(modulePath): prevent duplicate asset emission
|
||||
- fix(modulePath): support watch mode
|
||||
- chore: fix jsdoc
|
||||
- chore: improve logging message clarity and consistency
|
||||
- chore(deps): update all non-major dependencies
|
||||
- chore: update eslint config
|
||||
- chore: replace `tseslint.config` with `defineConfig`
|
||||
- chore: remove redundant external id
|
||||
- chore: rename the file `esm` to `esmShim`
|
||||
- docs: update
|
||||
|
||||
### v5.0.0-beta.3 (_2025-11-01_)
|
||||
|
||||
See [v5.0.0-beta.3 changelog](https://github.com/alex8088/electron-vite/blob/v5.0.0-beta.3/CHANGELOG.md)
|
||||
|
||||
### v5.0.0-beta.2 (_2025-10-30_)
|
||||
|
||||
See [v5.0.0-beta.2 changelog](https://github.com/alex8088/electron-vite/blob/v5.0.0-beta.2/CHANGELOG.md)
|
||||
|
||||
### v5.0.0-beta.1 (_2025-10-29_)
|
||||
|
||||
See [v5.0.0-beta.1 changelog](https://github.com/alex8088/electron-vite/blob/v5.0.0-beta.1/CHANGELOG.md)
|
||||
|
||||
### v5.0.0-beta.0 (_2025-10-19_)
|
||||
|
||||
See [v5.0.0-beta.0 changelog](https://github.com/alex8088/electron-vite/blob/v5.0.0-beta.0/CHANGELOG.md)
|
||||
|
||||
### v4.0.1 (_2025-09-21_)
|
||||
|
||||
- perf: build compatibility target for Electron 38
|
||||
|
||||
### v4.0.0 (_2025-07-06_)
|
||||
### v4.0.0-beta.0 (_2025-06-28_)
|
||||
|
||||
- refactor!: bump required node version to 20.19+, 22.12+
|
||||
- fix(deps)!: update Vite to v7 and remove cjs build
|
||||
@ -151,10 +9,6 @@ See [v5.0.0-beta.0 changelog](https://github.com/alex8088/electron-vite/blob/v5.
|
||||
- chore(deps): update all non-major dependencies
|
||||
- chore(deps): update lint-staged to v16
|
||||
|
||||
### v4.0.0-beta.0 (_2025-06-28_)
|
||||
|
||||
See [v4.0.0-beta.0 changelog](https://github.com/alex8088/electron-vite/blob/v4.0.0-beta.0/CHANGELOG.md)
|
||||
|
||||
### v3.1.0 (_2025-03-25_)
|
||||
|
||||
- fix(bytecodePlugin): optimize 'use strict' directive replacement ([#681](https://github.com/alex8088/electron-vite/issues/681))
|
||||
|
||||
16
README.md
16
README.md
@ -28,13 +28,13 @@
|
||||
## Features
|
||||
|
||||
- ⚡️ [Vite](https://vitejs.dev) powered and use the same way.
|
||||
- 🛠 Pre-configure with sensible defaults optimized for Electron.
|
||||
- 💡 Optimize asset handling for Electron main process.
|
||||
- 🚀 Fast HMR & hot reloading.
|
||||
- 🔥 Isolated build for multi-entry application development.
|
||||
- ✨ Simplify multi-threading development.
|
||||
- 🔒 Compile code to v8 bytecode to protect source code.
|
||||
- 🔌 Easy to debug in IDEs such as VSCode or WebStorm.
|
||||
- 🛠 Pre-configured for Electron, don't worry about configuration.
|
||||
- 💡 Optimize asset handling (Node.js addons, WebAssembly, Worker Thread, etc).
|
||||
- 🚀 Fast HMR for renderer processes.
|
||||
- 🔥 Hot reloading for main process and preload scripts.
|
||||
- 🔌 Easy to debug in IDEs like VSCode or WebStorm.
|
||||
- 🔒 Compile to v8 bytecode to protect source code.
|
||||
- 🏷️ Support for TypeScript decorators.
|
||||
- 📦 Out-of-the-box support for TypeScript, Vue, React, Svelte, SolidJS and more.
|
||||
|
||||
## Usage
|
||||
@ -83,7 +83,7 @@ export default {
|
||||
Clone the [electron-vite-boilerplate](https://github.com/alex8088/electron-vite-boilerplate) or use the [create-electron](https://github.com/alex8088/quick-start/tree/master/packages/create-electron) tool to scaffold your project.
|
||||
|
||||
```bash
|
||||
npm create @quick-start/electron@latest
|
||||
npm create @quick-start/electron
|
||||
```
|
||||
|
||||
Currently supported template presets include:
|
||||
|
||||
@ -1,15 +0,0 @@
|
||||
const vm = require('node:vm')
|
||||
const v8 = require('node:v8')
|
||||
|
||||
v8.setFlagsFromString('--no-lazy')
|
||||
v8.setFlagsFromString('--no-flush-bytecode')
|
||||
|
||||
const params = ['exports', 'require', 'module', '__filename', '__dirname']
|
||||
|
||||
module.exports = function compile(code) {
|
||||
if (typeof code !== 'string') throw new TypeError('Compilation source must be a string')
|
||||
const { cachedData } = vm.compileFunction(code, params, { produceCachedData: true })
|
||||
if (!Buffer.isBuffer(cachedData)) throw new Error('V8 did not produce cached data')
|
||||
// Explicit wire format works across both Node IPC and Electron structured clone.
|
||||
return { sourceLength: code.length, cachedData: cachedData.toString('base64') }
|
||||
}
|
||||
@ -1,109 +0,0 @@
|
||||
const { app, BrowserWindow, ipcMain } = require('electron')
|
||||
const path = require('node:path')
|
||||
const RpcPeer = require('./rpc-peer.cjs')
|
||||
const compile = require('./bytecode-compiler.cjs')
|
||||
|
||||
if (process.platform === 'darwin') {
|
||||
app.dock.hide()
|
||||
}
|
||||
|
||||
const channel = 'electron-vite:bytecode:rpc'
|
||||
const readyChannel = 'electron-vite:bytecode:ready'
|
||||
let win
|
||||
let rendererRPC
|
||||
let rendererStarting
|
||||
let stopping = false
|
||||
|
||||
function fail(error) {
|
||||
console.error(error)
|
||||
parentRPC.close(error)
|
||||
rendererRPC?.close(error)
|
||||
app.exit(1)
|
||||
}
|
||||
|
||||
const parentRPC = new RpcPeer(
|
||||
message =>
|
||||
new Promise((resolve, reject) => {
|
||||
if (!process.connected || !process.send) return reject(new Error('Parent IPC is disconnected'))
|
||||
process.send(message, error => (error ? reject(error) : resolve()))
|
||||
})
|
||||
)
|
||||
|
||||
function createRenderer() {
|
||||
return new Promise((resolve, reject) => {
|
||||
let ready = false
|
||||
const timer = setTimeout(() => finish(new Error('Compiler preload readiness timed out')), 30000)
|
||||
function finish(error) {
|
||||
clearTimeout(timer)
|
||||
ipcMain.removeListener(readyChannel, onReady)
|
||||
if (error) reject(error)
|
||||
else {
|
||||
ready = true
|
||||
resolve()
|
||||
}
|
||||
}
|
||||
function onReady(event) {
|
||||
if (event.sender === win.webContents) finish()
|
||||
}
|
||||
function onFailure(error) {
|
||||
if (stopping) return
|
||||
if (ready) fail(error)
|
||||
else finish(error)
|
||||
}
|
||||
ipcMain.on(readyChannel, onReady)
|
||||
win = new BrowserWindow({
|
||||
show: false,
|
||||
webPreferences: {
|
||||
preload: path.join(__dirname, 'electron-bytecode-preload.cjs'),
|
||||
sandbox: false,
|
||||
contextIsolation: true
|
||||
}
|
||||
})
|
||||
rendererRPC = new RpcPeer(message => {
|
||||
if (win.isDestroyed()) throw new Error('Compiler window is closed')
|
||||
win.webContents.send(channel, message)
|
||||
})
|
||||
ipcMain.on(channel, (event, message) => {
|
||||
if (!win.isDestroyed() && event.sender === win.webContents) void rendererRPC.receive(message)
|
||||
})
|
||||
win.webContents.on('preload-error', (_event, _path, error) => onFailure(error))
|
||||
win.webContents.on('render-process-gone', (_event, details) => {
|
||||
onFailure(new Error(`Compiler renderer exited: ${details.reason}`))
|
||||
})
|
||||
win.on('closed', () => onFailure(new Error('Compiler window closed unexpectedly')))
|
||||
win.loadURL('data:text/html,<!doctype html><html></html>').catch(onFailure)
|
||||
})
|
||||
}
|
||||
|
||||
const initialized = app.whenReady().then(() => true)
|
||||
parentRPC.register('ready', () => initialized)
|
||||
parentRPC.register('compile', async (target, code) => {
|
||||
await initialized
|
||||
if (target === 'main') return compile(code)
|
||||
if (target === 'preload') {
|
||||
rendererStarting ||= createRenderer()
|
||||
await rendererStarting
|
||||
return rendererRPC.request('compile', code)
|
||||
}
|
||||
throw new Error(`Invalid bytecode target: ${target}`)
|
||||
})
|
||||
initialized.catch(fail)
|
||||
|
||||
process.on('message', message => {
|
||||
if (message?.type === 'shutdown') {
|
||||
stopping = true
|
||||
app.quit()
|
||||
} else {
|
||||
void parentRPC.receive(message)
|
||||
}
|
||||
})
|
||||
process.on('disconnect', () => {
|
||||
stopping = true
|
||||
app.quit()
|
||||
})
|
||||
app.on('before-quit', () => {
|
||||
stopping = true
|
||||
parentRPC.close()
|
||||
rendererRPC?.close()
|
||||
})
|
||||
if (!process.send) fail(new Error('Bytecode compiler must be launched with an IPC channel'))
|
||||
@ -1,10 +0,0 @@
|
||||
const { ipcRenderer } = require('electron')
|
||||
const RpcPeer = require('./rpc-peer.cjs')
|
||||
const compile = require('./bytecode-compiler.cjs')
|
||||
|
||||
const channel = 'electron-vite:bytecode:rpc'
|
||||
const rpc = new RpcPeer(message => ipcRenderer.send(channel, message))
|
||||
rpc.register('ready', () => true)
|
||||
rpc.register('compile', compile)
|
||||
ipcRenderer.on(channel, (_event, message) => void rpc.receive(message))
|
||||
ipcRenderer.send('electron-vite:bytecode:ready')
|
||||
@ -1,89 +0,0 @@
|
||||
// Transport-independent peer. Messages must be JSON serializable.
|
||||
class RpcPeer {
|
||||
constructor(send, timeout = 30000) {
|
||||
this.send = send
|
||||
this.timeout = timeout
|
||||
this.methods = new Map()
|
||||
this.pending = new Map()
|
||||
this.nextId = 0
|
||||
this.closed = false
|
||||
}
|
||||
|
||||
register(cmd, method) {
|
||||
this.methods.set(cmd, method)
|
||||
return this
|
||||
}
|
||||
|
||||
request(cmd, ...args) {
|
||||
if (this.closed) return Promise.reject(new Error('RPC connection is closed'))
|
||||
const invocationId = this.nextId++
|
||||
return new Promise((resolve, reject) => {
|
||||
const timer = setTimeout(() => {
|
||||
this.pending.delete(invocationId)
|
||||
reject(new Error(`RPC request timed out: ${cmd}`))
|
||||
}, this.timeout)
|
||||
this.pending.set(invocationId, { resolve, reject, timer })
|
||||
Promise.resolve()
|
||||
.then(() => this.send({ type: 'request', invocationId, cmd, args }))
|
||||
.catch(error => {
|
||||
const pending = this.pending.get(invocationId)
|
||||
if (!pending) return
|
||||
clearTimeout(timer)
|
||||
this.pending.delete(invocationId)
|
||||
reject(error)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
async receive(message) {
|
||||
if (this.closed || !message || !Number.isSafeInteger(message.invocationId)) return
|
||||
const { type, invocationId } = message
|
||||
if (type === 'response') {
|
||||
const pending = this.pending.get(invocationId)
|
||||
if (!pending) return
|
||||
this.pending.delete(invocationId)
|
||||
clearTimeout(pending.timer)
|
||||
if (message.error) {
|
||||
const error = new Error(message.error.message)
|
||||
error.name = message.error.name || 'Error'
|
||||
if (message.error.stack) error.stack = message.error.stack
|
||||
pending.reject(error)
|
||||
} else {
|
||||
pending.resolve(message.result)
|
||||
}
|
||||
return
|
||||
}
|
||||
if (type !== 'request' || typeof message.cmd !== 'string' || !Array.isArray(message.args)) return
|
||||
const response = { type: 'response', invocationId }
|
||||
try {
|
||||
const method = this.methods.get(message.cmd)
|
||||
if (!method) throw new Error(`Invalid method: ${message.cmd}`)
|
||||
response.result = await method(...message.args)
|
||||
} catch (error) {
|
||||
response.error = {
|
||||
name: error instanceof Error ? error.name : 'Error',
|
||||
message: error instanceof Error ? error.message : String(error),
|
||||
stack: error instanceof Error ? error.stack : undefined
|
||||
}
|
||||
}
|
||||
if (!this.closed) {
|
||||
try {
|
||||
await this.send(response)
|
||||
} catch (error) {
|
||||
this.close(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
close(error = new Error('RPC connection is closed')) {
|
||||
this.closed = true
|
||||
for (const pending of this.pending.values()) {
|
||||
clearTimeout(pending.timer)
|
||||
pending.reject(error)
|
||||
}
|
||||
this.pending.clear()
|
||||
this.methods.clear()
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = RpcPeer
|
||||
@ -1,11 +1,11 @@
|
||||
// ts-check
|
||||
import { defineConfig } from 'eslint/config'
|
||||
|
||||
import eslint from '@eslint/js'
|
||||
import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended'
|
||||
import globals from 'globals'
|
||||
import tseslint from 'typescript-eslint'
|
||||
|
||||
export default defineConfig(
|
||||
export default tseslint.config(
|
||||
{ ignores: ['**/node_modules', '**/dist', '**/bin'] },
|
||||
eslint.configs.recommended,
|
||||
tseslint.configs.recommended,
|
||||
@ -29,7 +29,6 @@ export default defineConfig(
|
||||
},
|
||||
rules: {
|
||||
'prettier/prettier': 'warn',
|
||||
'no-empty': ['warn', { allowEmptyCatch: true }],
|
||||
'@typescript-eslint/ban-ts-comment': ['error', { 'ts-ignore': 'allow-with-description' }],
|
||||
'@typescript-eslint/explicit-function-return-type': [
|
||||
'error',
|
||||
@ -53,10 +52,6 @@ export default defineConfig(
|
||||
allowTaggedTemplates: true,
|
||||
allowTernary: true
|
||||
}
|
||||
],
|
||||
'@typescript-eslint/consistent-type-imports': [
|
||||
'error',
|
||||
{ prefer: 'type-imports', disallowTypeAnnotations: false }
|
||||
]
|
||||
}
|
||||
},
|
||||
|
||||
2
node.d.ts
vendored
2
node.d.ts
vendored
@ -1,6 +1,6 @@
|
||||
// node worker
|
||||
declare module '*?nodeWorker' {
|
||||
import type { Worker, WorkerOptions } from 'node:worker_threads'
|
||||
import { Worker, WorkerOptions } from 'node:worker_threads'
|
||||
export default function (options: WorkerOptions): Worker
|
||||
}
|
||||
|
||||
|
||||
52
package.json
52
package.json
@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "electron-vite",
|
||||
"version": "6.0.0",
|
||||
"version": "4.0.0-beta.0",
|
||||
"description": "Electron build tooling based on Vite",
|
||||
"type": "module",
|
||||
"main": "./dist/index.js",
|
||||
@ -61,7 +61,7 @@
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@swc/core": "^1.0.0",
|
||||
"vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
|
||||
"vite": "^5.0.0 || ^6.0.0 || ^7.0.0"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"@swc/core": {
|
||||
@ -69,39 +69,39 @@
|
||||
}
|
||||
},
|
||||
"devDependencies": {
|
||||
"@eslint/js": "^10.0.1",
|
||||
"@eslint/js": "^9.29.0",
|
||||
"@rollup/plugin-json": "^6.1.0",
|
||||
"@rollup/plugin-node-resolve": "^16.0.3",
|
||||
"@rollup/plugin-typescript": "^12.3.0",
|
||||
"@swc/core": "^1.16.2",
|
||||
"@types/babel__core": "^7.20.5",
|
||||
"@types/node": "^22.20.4",
|
||||
"eslint": "^10.11.0",
|
||||
"eslint-config-prettier": "^10.1.8",
|
||||
"eslint-plugin-prettier": "^5.5.6",
|
||||
"globals": "^17.12.0",
|
||||
"lint-staged": "^17.5.1",
|
||||
"prettier": "^3.9.9",
|
||||
"rollup": "^4.63.5",
|
||||
"rollup-plugin-dts": "^6.5.1",
|
||||
"@rollup/plugin-node-resolve": "^16.0.1",
|
||||
"@rollup/plugin-typescript": "^12.1.3",
|
||||
"@swc/core": "^1.12.7",
|
||||
"@types/node": "^22.15.33",
|
||||
"eslint": "^9.29.0",
|
||||
"eslint-config-prettier": "^10.1.5",
|
||||
"eslint-plugin-prettier": "^5.5.1",
|
||||
"globals": "^16.2.0",
|
||||
"lint-staged": "^16.1.2",
|
||||
"prettier": "^3.6.2",
|
||||
"rollup": "^4.44.1",
|
||||
"rollup-plugin-dts": "^6.2.1",
|
||||
"rollup-plugin-rm": "^1.0.2",
|
||||
"simple-git-hooks": "^2.14.0",
|
||||
"simple-git-hooks": "^2.13.0",
|
||||
"tslib": "^2.8.1",
|
||||
"typescript": "^5.9.3",
|
||||
"typescript-eslint": "^8.70.1",
|
||||
"vite": "^8.3.1"
|
||||
"typescript": "^5.8.3",
|
||||
"typescript-eslint": "^8.35.0",
|
||||
"vite": "^7.0.0"
|
||||
},
|
||||
"dependencies": {
|
||||
"@babel/core": "^7.29.7",
|
||||
"@babel/plugin-transform-arrow-functions": "^7.29.7",
|
||||
"cac": "^7.0.0",
|
||||
"magic-string": "^1.4.2",
|
||||
"picocolors": "^1.1.1",
|
||||
"rolldown": "~1.2.10"
|
||||
"@babel/core": "^7.27.7",
|
||||
"@babel/plugin-transform-arrow-functions": "^7.27.1",
|
||||
"cac": "^6.7.14",
|
||||
"esbuild": "^0.25.5",
|
||||
"magic-string": "^0.30.17",
|
||||
"picocolors": "^1.1.1"
|
||||
},
|
||||
"pnpm": {
|
||||
"onlyBuiltDependencies": [
|
||||
"@swc/core",
|
||||
"esbuild",
|
||||
"simple-git-hooks"
|
||||
]
|
||||
}
|
||||
|
||||
2655
pnpm-lock.yaml
generated
2655
pnpm-lock.yaml
generated
File diff suppressed because it is too large
Load Diff
@ -9,7 +9,7 @@ import rm from 'rollup-plugin-rm'
|
||||
const require = createRequire(import.meta.url)
|
||||
const pkg = require('./package.json')
|
||||
|
||||
const external = [...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.peerDependencies || {})]
|
||||
const external = ['esbuild', ...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.peerDependencies || {})]
|
||||
|
||||
export default defineConfig([
|
||||
{
|
||||
@ -26,7 +26,7 @@ export default defineConfig([
|
||||
plugins: [
|
||||
rm('dist', 'buildStart'),
|
||||
json(),
|
||||
ts({ compilerOptions: { rootDir: 'src', outDir: 'dist', declaration: true, declarationDir: 'dist/types' } }),
|
||||
ts({ compilerOptions: { rootDir: 'src', declaration: true, declarationDir: 'dist/types' } }),
|
||||
resolve()
|
||||
],
|
||||
treeshake: {
|
||||
@ -35,7 +35,6 @@ export default defineConfig([
|
||||
},
|
||||
{
|
||||
input: 'dist/types/index.d.ts',
|
||||
external: ['vite'],
|
||||
output: [{ file: pkg.types, format: 'es' }],
|
||||
plugins: [dts(), rm('dist/types', 'buildEnd')]
|
||||
}
|
||||
|
||||
67
src/build.ts
67
src/build.ts
@ -1,56 +1,33 @@
|
||||
import { build as viteBuild, mergeConfig } from 'vite'
|
||||
import { type InlineConfig, type MainViteConfig, type PreloadViteConfig, resolveConfig } from './config'
|
||||
import { BytecodeCompiler } from './bytecodeCompiler'
|
||||
import { asyncFlatten } from './utils'
|
||||
|
||||
async function usesBytecode(config?: MainViteConfig | PreloadViteConfig): Promise<boolean> {
|
||||
if (!config) return false
|
||||
if (config.build?.bytecode) return true
|
||||
const plugins = await asyncFlatten(config.plugins || [])
|
||||
return plugins.some(plugin => plugin && typeof plugin === 'object' && plugin.name === 'vite:bytecode')
|
||||
}
|
||||
import { build as viteBuild } from 'vite'
|
||||
import { type InlineConfig, resolveConfig } from './config'
|
||||
|
||||
/**
|
||||
* Bundles the electron app for production.
|
||||
*/
|
||||
export async function build(inlineConfig: InlineConfig = {}): Promise<void> {
|
||||
process.env.NODE_ENV_ELECTRON_VITE = 'production'
|
||||
|
||||
const bytecodeCompiler = new BytecodeCompiler()
|
||||
const config = await resolveConfig(
|
||||
mergeConfig(inlineConfig, {
|
||||
plugins: [{ name: 'vite:electron-bytecode-build', api: { compiler: bytecodeCompiler } }]
|
||||
}),
|
||||
'build',
|
||||
'production'
|
||||
)
|
||||
|
||||
if (!config.config) {
|
||||
return
|
||||
const config = await resolveConfig(inlineConfig, 'build', 'production')
|
||||
if (config.config) {
|
||||
const mainViteConfig = config.config?.main
|
||||
if (mainViteConfig) {
|
||||
if (mainViteConfig.build?.watch) {
|
||||
mainViteConfig.build.watch = null
|
||||
}
|
||||
|
||||
const hasBytecode = (await usesBytecode(config.config.main)) || (await usesBytecode(config.config.preload))
|
||||
|
||||
const buildTargets = async (): Promise<void> => {
|
||||
// Build targets in order: main -> preload -> renderer
|
||||
for (const target of ['main', 'preload', 'renderer'] as const) {
|
||||
const viteConfig = config.config?.[target]
|
||||
if (viteConfig) {
|
||||
// Disable watch mode in production builds
|
||||
if (viteConfig.build?.watch) {
|
||||
viteConfig.build.watch = null
|
||||
await viteBuild(mainViteConfig)
|
||||
}
|
||||
await viteBuild(viteConfig)
|
||||
const preloadViteConfig = config.config?.preload
|
||||
if (preloadViteConfig) {
|
||||
if (preloadViteConfig.build?.watch) {
|
||||
preloadViteConfig.build.watch = null
|
||||
}
|
||||
await viteBuild(preloadViteConfig)
|
||||
}
|
||||
const rendererViteConfig = config.config?.renderer
|
||||
if (rendererViteConfig) {
|
||||
if (rendererViteConfig.build?.watch) {
|
||||
rendererViteConfig.build.watch = null
|
||||
}
|
||||
await viteBuild(rendererViteConfig)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!hasBytecode) return buildTargets()
|
||||
|
||||
try {
|
||||
await bytecodeCompiler.start()
|
||||
await buildTargets()
|
||||
} finally {
|
||||
await bytecodeCompiler.stop()
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,188 +0,0 @@
|
||||
import { type ChildProcess, spawn } from 'node:child_process'
|
||||
import path from 'node:path'
|
||||
import { createRequire } from 'node:module'
|
||||
import { getElectronPath } from './electron'
|
||||
|
||||
const require = createRequire(import.meta.url)
|
||||
const RPC_TIMEOUT = 30_000
|
||||
const SHUTDOWN_TIMEOUT = 3_000
|
||||
|
||||
export type BytecodeCompileResult = {
|
||||
sourceLength: number
|
||||
/** Base64-encoded V8 cachedData; decode with Buffer.from(cachedData, 'base64'). */
|
||||
cachedData: string
|
||||
}
|
||||
|
||||
export type BytecodeTarget = 'main' | 'preload'
|
||||
|
||||
type CompilerResponse = {
|
||||
type: 'response'
|
||||
invocationId: number
|
||||
result?: unknown
|
||||
error?: { name: string; message: string; stack?: string }
|
||||
}
|
||||
|
||||
type PendingRequest = {
|
||||
resolve: (value: unknown) => void
|
||||
reject: (reason: Error) => void
|
||||
timer: ReturnType<typeof setTimeout>
|
||||
}
|
||||
|
||||
export class BytecodeCompiler {
|
||||
private ps?: ChildProcess
|
||||
private rpcMap = new Map<number, PendingRequest>()
|
||||
private invocationId = 0
|
||||
private starting?: Promise<void>
|
||||
private stopping?: Promise<void>
|
||||
private ready = false
|
||||
private stderr = ''
|
||||
|
||||
start(): Promise<void> {
|
||||
if (this.stopping) return Promise.reject(new Error('BytecodeCompiler is stopping'))
|
||||
if (this.starting) return this.starting
|
||||
if (this.ready) return Promise.resolve()
|
||||
if (this.ps) return Promise.reject(new Error('Previous Electron process has not closed; await stop() first'))
|
||||
this.starting = this.initialize().finally(() => {
|
||||
this.starting = undefined
|
||||
})
|
||||
return this.starting
|
||||
}
|
||||
|
||||
private async initialize(): Promise<void> {
|
||||
const env: NodeJS.ProcessEnv = { ...process.env, ELECTRON_VITE_RPC: 'true' }
|
||||
delete env.ELECTRON_RUN_AS_NODE
|
||||
this.stderr = ''
|
||||
const compilerPath = path.join(
|
||||
path.dirname(require.resolve('electron-vite/package.json')),
|
||||
'bin',
|
||||
'electron-bytecode-main.cjs'
|
||||
)
|
||||
const ps = spawn(getElectronPath(), [compilerPath], {
|
||||
stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
|
||||
windowsHide: true,
|
||||
env
|
||||
})
|
||||
this.ps = ps
|
||||
if (ps.stderr) {
|
||||
ps.stderr.setEncoding('utf8')
|
||||
ps.stderr.on('data', (chunk: string) => {
|
||||
if (this.ps === ps) this.stderr = (this.stderr + chunk).slice(-64 * 1024)
|
||||
})
|
||||
}
|
||||
ps.on('message', (message: CompilerResponse) => {
|
||||
if (this.ps !== ps || !message || message.type !== 'response') return
|
||||
const pending = this.rpcMap.get(message.invocationId)
|
||||
if (!pending) return
|
||||
clearTimeout(pending.timer)
|
||||
this.rpcMap.delete(message.invocationId)
|
||||
if (message.error) {
|
||||
const error = new Error(message.error.message)
|
||||
error.name = message.error.name
|
||||
if (message.error.stack) error.stack = message.error.stack
|
||||
pending.reject(error)
|
||||
} else pending.resolve(message.result)
|
||||
})
|
||||
ps.on('error', error => {
|
||||
if (this.ps === ps) this.rejectPending(error)
|
||||
})
|
||||
ps.on('disconnect', () => {
|
||||
if (this.ps === ps) this.rejectPending(new Error('Electron IPC disconnected'))
|
||||
})
|
||||
ps.on('exit', (code, signal) => {
|
||||
if (this.ps === ps) this.rejectPending(new Error('Electron exited (code ' + code + ', signal ' + signal + ')'))
|
||||
})
|
||||
ps.on('close', () => {
|
||||
if (this.ps === ps) {
|
||||
this.rejectPending(new Error('Electron process closed'))
|
||||
this.ps = undefined
|
||||
}
|
||||
})
|
||||
try {
|
||||
await this.sendRequest('ready', [])
|
||||
if (!ps.connected || this.stopping) throw new Error('Electron stopped during initialization')
|
||||
this.ready = true
|
||||
} catch (error) {
|
||||
await this.stop()
|
||||
throw error
|
||||
}
|
||||
}
|
||||
|
||||
compile(target: BytecodeTarget, code: string): Promise<BytecodeCompileResult> {
|
||||
return this.request<BytecodeCompileResult>('compile', target, code)
|
||||
}
|
||||
|
||||
async request<T = unknown>(cmd: string, ...args: unknown[]): Promise<T> {
|
||||
if (!this.ready || this.stopping) throw new Error('BytecodeCompiler is not ready; await start() first')
|
||||
return this.sendRequest(cmd, args) as Promise<T>
|
||||
}
|
||||
|
||||
private sendRequest(cmd: string, args: unknown[]): Promise<unknown> {
|
||||
const ps = this.ps
|
||||
if (!ps?.connected) return Promise.reject(new Error('Electron IPC is not connected'))
|
||||
const invocationId = this.invocationId++
|
||||
return new Promise((resolve, reject) => {
|
||||
const fail = (error: Error): void => {
|
||||
const pending = this.rpcMap.get(invocationId)
|
||||
if (!pending) return
|
||||
clearTimeout(pending.timer)
|
||||
this.rpcMap.delete(invocationId)
|
||||
reject(this.withStderr(error))
|
||||
}
|
||||
const timer = setTimeout(() => fail(new Error('Electron RPC timed out: ' + cmd)), RPC_TIMEOUT)
|
||||
this.rpcMap.set(invocationId, { resolve, reject, timer })
|
||||
try {
|
||||
ps.send({ type: 'request', invocationId, cmd, args }, error => {
|
||||
if (error) fail(error)
|
||||
})
|
||||
} catch (error) {
|
||||
fail(error instanceof Error ? error : new Error(String(error)))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
private rejectPending(error: Error): void {
|
||||
this.ready = false
|
||||
if (this.rpcMap.size) this.withStderr(error)
|
||||
for (const pending of this.rpcMap.values()) {
|
||||
clearTimeout(pending.timer)
|
||||
pending.reject(error)
|
||||
}
|
||||
this.rpcMap.clear()
|
||||
}
|
||||
|
||||
private withStderr(error: Error): Error {
|
||||
const stderr = this.stderr.trim()
|
||||
if (stderr) {
|
||||
const stack = error.stack
|
||||
error.message += '\n' + stderr
|
||||
if (stack) error.stack = stack + '\n' + stderr
|
||||
}
|
||||
return error
|
||||
}
|
||||
|
||||
stop(): Promise<void> {
|
||||
if (this.stopping) return this.stopping
|
||||
this.rejectPending(new Error('BytecodeCompiler stopped'))
|
||||
const ps = this.ps
|
||||
if (!ps) return Promise.resolve()
|
||||
this.stopping = new Promise<void>(resolve => {
|
||||
const timer = setTimeout(() => ps.kill('SIGKILL'), SHUTDOWN_TIMEOUT)
|
||||
ps.once('close', () => {
|
||||
clearTimeout(timer)
|
||||
resolve()
|
||||
})
|
||||
if (ps.connected) {
|
||||
try {
|
||||
ps.send({ type: 'shutdown' }, error => {
|
||||
if (error) ps.kill()
|
||||
})
|
||||
} catch {
|
||||
ps.kill()
|
||||
}
|
||||
} else ps.kill()
|
||||
}).finally(() => {
|
||||
this.stopping = undefined
|
||||
})
|
||||
return this.stopping
|
||||
}
|
||||
}
|
||||
535
src/config.ts
535
src/config.ts
@ -1,138 +1,70 @@
|
||||
import path from 'node:path'
|
||||
import fs from 'node:fs'
|
||||
import { pathToFileURL } from 'node:url'
|
||||
import { createRequire } from 'node:module'
|
||||
import colors from 'picocolors'
|
||||
import {
|
||||
type UserConfig as ViteConfig,
|
||||
type UserConfigExport as ViteConfigExport,
|
||||
type ConfigEnv,
|
||||
type PluginOption,
|
||||
type Plugin,
|
||||
type BuildEnvironmentOptions as ViteBuildOptions,
|
||||
type LogLevel,
|
||||
createLogger,
|
||||
mergeConfig,
|
||||
normalizePath
|
||||
} from 'vite'
|
||||
import { build } from 'esbuild'
|
||||
|
||||
import {
|
||||
electronMainConfigPresetPlugin,
|
||||
electronMainConfigValidatorPlugin,
|
||||
electronPreloadConfigPresetPlugin,
|
||||
electronPreloadConfigValidatorPlugin,
|
||||
electronRendererConfigPresetPlugin,
|
||||
electronRendererConfigValidatorPlugin
|
||||
} from './plugins/electron'
|
||||
import { electronMainVitePlugin, electronPreloadVitePlugin, electronRendererVitePlugin } from './plugins/electron'
|
||||
import assetPlugin from './plugins/asset'
|
||||
import workerPlugin from './plugins/worker'
|
||||
import importMetaPlugin from './plugins/importMeta'
|
||||
import esmShimPlugin from './plugins/esmShim'
|
||||
import esmShimPlugin from './plugins/esm'
|
||||
import modulePathPlugin from './plugins/modulePath'
|
||||
import isolateEntriesPlugin from './plugins/isolateEntries'
|
||||
import { type ExternalOptions, externalizeDepsPlugin } from './plugins/externalizeDeps'
|
||||
import { type BytecodeOptions, bytecodePlugin } from './plugins/bytecode'
|
||||
import { isObject, isFilePathESM, cloneConfig, asyncFlatten } from './utils'
|
||||
import { findConfigFile, bundleConfigFile, loadConfigFormBundledFile } from './load'
|
||||
import { isObject, isFilePathESM } from './utils'
|
||||
|
||||
export { defineConfig as defineViteConfig } from 'vite'
|
||||
|
||||
interface IsolatedEntriesMixin {
|
||||
/**
|
||||
* Build each entry point as an isolated bundle without code splitting.
|
||||
*
|
||||
* When enabled, each entry will include all its dependencies inline,
|
||||
* preventing automatic code splitting across entries and ensuring each
|
||||
* output file is fully standalone.
|
||||
*
|
||||
* **Important**: When using `isolatedEntries` in `preload` config, you
|
||||
* should also disable `build.externalizeDeps` to ensure third-party dependencies
|
||||
* from `node_modules` are bundled together, which is required for Electron
|
||||
* sandbox support.
|
||||
*
|
||||
* @experimental
|
||||
* @default false
|
||||
*/
|
||||
isolatedEntries?: boolean
|
||||
}
|
||||
|
||||
interface ExternalizeDepsMixin {
|
||||
/**
|
||||
* Options pass on to `externalizeDeps` plugin in electron-vite.
|
||||
*
|
||||
* Automatically externalize dependencies.
|
||||
*
|
||||
* @default true
|
||||
*/
|
||||
externalizeDeps?: boolean | ExternalOptions
|
||||
}
|
||||
|
||||
interface BytecodeMixin {
|
||||
/**
|
||||
* Options pass on to `bytecode` plugin in electron-vite.
|
||||
* https://electron-vite.org/guide/source-code-protection#options
|
||||
*
|
||||
* Compiles source code to v8 bytecode and works only in the `build` command.
|
||||
*/
|
||||
bytecode?: boolean | BytecodeOptions
|
||||
}
|
||||
|
||||
interface MainBuildOptions extends ViteBuildOptions, ExternalizeDepsMixin, BytecodeMixin {}
|
||||
|
||||
interface PreloadBuildOptions extends ViteBuildOptions, ExternalizeDepsMixin, BytecodeMixin, IsolatedEntriesMixin {}
|
||||
|
||||
interface RendererBuildOptions extends ViteBuildOptions, IsolatedEntriesMixin {}
|
||||
|
||||
interface BaseViteConfig<T> extends Omit<ViteConfig, 'build'> {
|
||||
/**
|
||||
* Build specific options
|
||||
*/
|
||||
build?: T
|
||||
}
|
||||
|
||||
export interface MainViteConfig extends BaseViteConfig<MainBuildOptions> {}
|
||||
|
||||
export interface PreloadViteConfig extends BaseViteConfig<PreloadBuildOptions> {}
|
||||
|
||||
export interface RendererViteConfig extends BaseViteConfig<RendererBuildOptions> {}
|
||||
|
||||
export interface UserConfig {
|
||||
/**
|
||||
* Vite config options for electron main process
|
||||
*
|
||||
* @see https://vitejs.dev/config/
|
||||
* https://vitejs.dev/config/
|
||||
*/
|
||||
main?: MainViteConfig
|
||||
main?: ViteConfig & { configFile?: string | false }
|
||||
/**
|
||||
* Vite config options for electron renderer process
|
||||
*
|
||||
* @see https://vitejs.dev/config/
|
||||
* https://vitejs.dev/config/
|
||||
*/
|
||||
renderer?: RendererViteConfig
|
||||
renderer?: ViteConfig & { configFile?: string | false }
|
||||
/**
|
||||
* Vite config options for electron preload scripts
|
||||
* Vite config options for electron preload files
|
||||
*
|
||||
* @see https://vitejs.dev/config/
|
||||
* https://vitejs.dev/config/
|
||||
*/
|
||||
preload?: PreloadViteConfig
|
||||
preload?: ViteConfig & { configFile?: string | false }
|
||||
}
|
||||
|
||||
export type ElectronViteConfigFnObject = (env: ConfigEnv) => UserConfig
|
||||
export type ElectronViteConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>
|
||||
export type ElectronViteConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>
|
||||
|
||||
export type ElectronViteConfigExport =
|
||||
UserConfig | Promise<UserConfig> | ElectronViteConfigFnObject | ElectronViteConfigFnPromise | ElectronViteConfigFn
|
||||
|
||||
export interface ElectronViteConfig {
|
||||
/**
|
||||
* Type helper to make it easier to use `electron.vite.config.*`
|
||||
* accepts a direct {@link UserConfig} object, or a function that returns it.
|
||||
* The function receives a object that exposes two properties:
|
||||
* `command` (either `'build'` or `'serve'`), and `mode`.
|
||||
* Vite config options for electron main process
|
||||
*
|
||||
* https://vitejs.dev/config/
|
||||
*/
|
||||
export function defineConfig(config: UserConfig): UserConfig
|
||||
export function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>
|
||||
export function defineConfig(config: ElectronViteConfigFnObject): ElectronViteConfigFnObject
|
||||
export function defineConfig(config: ElectronViteConfigFnPromise): ElectronViteConfigFnPromise
|
||||
export function defineConfig(config: ElectronViteConfigExport): ElectronViteConfigExport
|
||||
export function defineConfig(config: ElectronViteConfigExport): ElectronViteConfigExport {
|
||||
return config
|
||||
main?: ViteConfigExport
|
||||
/**
|
||||
* Vite config options for electron renderer process
|
||||
*
|
||||
* https://vitejs.dev/config/
|
||||
*/
|
||||
renderer?: ViteConfigExport
|
||||
/**
|
||||
* Vite config options for electron preload files
|
||||
*
|
||||
* https://vitejs.dev/config/
|
||||
*/
|
||||
preload?: ViteConfigExport
|
||||
}
|
||||
|
||||
export type InlineConfig = Omit<ViteConfig, 'base'> & {
|
||||
@ -141,6 +73,31 @@ export type InlineConfig = Omit<ViteConfig, 'base'> & {
|
||||
ignoreConfigWarning?: boolean
|
||||
}
|
||||
|
||||
export type ElectronViteConfigFnObject = (env: ConfigEnv) => ElectronViteConfig
|
||||
export type ElectronViteConfigFnPromise = (env: ConfigEnv) => Promise<ElectronViteConfig>
|
||||
export type ElectronViteConfigFn = (env: ConfigEnv) => ElectronViteConfig | Promise<ElectronViteConfig>
|
||||
|
||||
export type ElectronViteConfigExport =
|
||||
| ElectronViteConfig
|
||||
| Promise<ElectronViteConfig>
|
||||
| ElectronViteConfigFnObject
|
||||
| ElectronViteConfigFnPromise
|
||||
| ElectronViteConfigFn
|
||||
|
||||
/**
|
||||
* Type helper to make it easier to use `electron.vite.config.*`
|
||||
* accepts a direct {@link ElectronViteConfig} object, or a function that returns it.
|
||||
* The function receives a object that exposes two properties:
|
||||
* `command` (either `'build'` or `'serve'`), and `mode`.
|
||||
*/
|
||||
export function defineConfig(config: ElectronViteConfig): ElectronViteConfig
|
||||
export function defineConfig(config: Promise<ElectronViteConfig>): Promise<ElectronViteConfig>
|
||||
export function defineConfig(config: ElectronViteConfigFnObject): ElectronViteConfigFnObject
|
||||
export function defineConfig(config: ElectronViteConfigExport): ElectronViteConfigExport
|
||||
export function defineConfig(config: ElectronViteConfigExport): ElectronViteConfigExport {
|
||||
return config
|
||||
}
|
||||
|
||||
export interface ResolvedConfig {
|
||||
config?: UserConfig
|
||||
configFile?: string
|
||||
@ -157,8 +114,7 @@ export async function resolveConfig(
|
||||
|
||||
process.env.NODE_ENV = defaultMode
|
||||
|
||||
const userConfig: UserConfig | undefined = {}
|
||||
|
||||
let userConfig: UserConfig | undefined
|
||||
let configFileDependencies: string[] = []
|
||||
|
||||
let { configFile } = config
|
||||
@ -167,7 +123,6 @@ export async function resolveConfig(
|
||||
mode,
|
||||
command
|
||||
}
|
||||
|
||||
const loadResult = await loadConfigFromFile(
|
||||
configEnv,
|
||||
configFile,
|
||||
@ -175,30 +130,70 @@ export async function resolveConfig(
|
||||
config.logLevel,
|
||||
config.ignoreConfigWarning
|
||||
)
|
||||
|
||||
if (loadResult) {
|
||||
const root = config.root
|
||||
delete config.root
|
||||
delete config.configFile
|
||||
|
||||
config.configFile = false
|
||||
|
||||
const outDir = config.build?.outDir
|
||||
|
||||
const { main, preload, renderer } = loadResult.config
|
||||
if (loadResult.config.main) {
|
||||
const mainViteConfig: ViteConfig = mergeConfig(loadResult.config.main, deepClone(config))
|
||||
|
||||
if (main) {
|
||||
userConfig.main = await new MainConfigFactory(main, config, { outDir, root }).build()
|
||||
mainViteConfig.mode = inlineConfig.mode || mainViteConfig.mode || defaultMode
|
||||
|
||||
if (outDir) {
|
||||
resetOutDir(mainViteConfig, outDir, 'main')
|
||||
}
|
||||
|
||||
if (preload) {
|
||||
userConfig.preload = await new PreloadConfigFactory(preload, config, { outDir, root }).build()
|
||||
mergePlugins(mainViteConfig, [
|
||||
...electronMainVitePlugin({ root }),
|
||||
assetPlugin(),
|
||||
workerPlugin(),
|
||||
modulePathPlugin(),
|
||||
importMetaPlugin(),
|
||||
esmShimPlugin()
|
||||
])
|
||||
|
||||
loadResult.config.main = mainViteConfig
|
||||
loadResult.config.main.configFile = false
|
||||
}
|
||||
|
||||
if (renderer) {
|
||||
userConfig.renderer = await new RendererConfigFactory(renderer, config, { outDir, root }).build()
|
||||
if (loadResult.config.preload) {
|
||||
const preloadViteConfig: ViteConfig = mergeConfig(loadResult.config.preload, deepClone(config))
|
||||
|
||||
preloadViteConfig.mode = inlineConfig.mode || preloadViteConfig.mode || defaultMode
|
||||
|
||||
if (outDir) {
|
||||
resetOutDir(preloadViteConfig, outDir, 'preload')
|
||||
}
|
||||
mergePlugins(preloadViteConfig, [
|
||||
...electronPreloadVitePlugin({ root }),
|
||||
assetPlugin(),
|
||||
importMetaPlugin(),
|
||||
esmShimPlugin()
|
||||
])
|
||||
|
||||
loadResult.config.preload = preloadViteConfig
|
||||
loadResult.config.preload.configFile = false
|
||||
}
|
||||
|
||||
if (loadResult.config.renderer) {
|
||||
const rendererViteConfig: ViteConfig = mergeConfig(loadResult.config.renderer, deepClone(config))
|
||||
|
||||
rendererViteConfig.mode = inlineConfig.mode || rendererViteConfig.mode || defaultMode
|
||||
|
||||
if (outDir) {
|
||||
resetOutDir(rendererViteConfig, outDir, 'renderer')
|
||||
}
|
||||
|
||||
mergePlugins(rendererViteConfig, electronRendererVitePlugin({ root }))
|
||||
|
||||
loadResult.config.renderer = rendererViteConfig
|
||||
loadResult.config.renderer.configFile = false
|
||||
}
|
||||
|
||||
userConfig = loadResult.config
|
||||
configFile = loadResult.path
|
||||
configFileDependencies = loadResult.dependencies
|
||||
}
|
||||
@ -213,109 +208,8 @@ export async function resolveConfig(
|
||||
return resolved
|
||||
}
|
||||
|
||||
export abstract class ConfigFactory<T extends MainViteConfig | PreloadViteConfig | RendererViteConfig> {
|
||||
constructor(
|
||||
protected readonly baseConfig: T,
|
||||
protected readonly inlineConfig: InlineConfig,
|
||||
protected readonly options: { outDir?: string; root?: string }
|
||||
) {
|
||||
baseConfig.build ??= {}
|
||||
baseConfig.build.rolldownOptions ??= baseConfig.build.rollupOptions
|
||||
}
|
||||
|
||||
async build(cleanMode?: boolean): Promise<T> {
|
||||
/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
|
||||
const config = mergeConfig(cloneConfig(this.baseConfig) as any, cloneConfig(this.inlineConfig)) as T
|
||||
|
||||
config.mode = this.inlineConfig.mode || config.mode || process.env.NODE_ENV
|
||||
|
||||
if (this.options.outDir) {
|
||||
resetOutDir(config, this.options.outDir, this.processType())
|
||||
}
|
||||
|
||||
const builtinPlugins = await this.resolveBuiltinPlugins(config, cleanMode)
|
||||
|
||||
config.plugins = builtinPlugins.concat(config.plugins || [])
|
||||
|
||||
return config
|
||||
}
|
||||
|
||||
protected abstract processType(): 'main' | 'preload' | 'renderer'
|
||||
|
||||
protected abstract resolveBuiltinPlugins(config: T, cleanMode?: boolean): Promise<PluginOption[]>
|
||||
}
|
||||
|
||||
export class MainConfigFactory extends ConfigFactory<MainViteConfig> {
|
||||
protected processType(): 'main' {
|
||||
return 'main'
|
||||
}
|
||||
|
||||
protected async resolveBuiltinPlugins(config: MainViteConfig, cleanMode?: boolean): Promise<PluginOption[]> {
|
||||
const configDrivenPlugins: PluginOption[] = await resolveConfigDrivenPlugins(config)
|
||||
|
||||
return cleanMode
|
||||
? [
|
||||
electronMainConfigPresetPlugin({ root: this.options.root }),
|
||||
assetPlugin(),
|
||||
importMetaPlugin(),
|
||||
esmShimPlugin(),
|
||||
...configDrivenPlugins
|
||||
]
|
||||
: [
|
||||
electronMainConfigPresetPlugin({ root: this.options.root }),
|
||||
electronMainConfigValidatorPlugin(),
|
||||
assetPlugin(),
|
||||
workerPlugin(),
|
||||
modulePathPlugin(this),
|
||||
importMetaPlugin(),
|
||||
esmShimPlugin(),
|
||||
...configDrivenPlugins
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
export class PreloadConfigFactory extends ConfigFactory<PreloadViteConfig> {
|
||||
protected processType(): 'preload' {
|
||||
return 'preload'
|
||||
}
|
||||
|
||||
protected async resolveBuiltinPlugins(config: PreloadViteConfig, cleanMode?: boolean): Promise<PluginOption[]> {
|
||||
const configDrivenPlugins: PluginOption[] = await resolveConfigDrivenPlugins(config)
|
||||
|
||||
return cleanMode
|
||||
? [
|
||||
electronPreloadConfigPresetPlugin({ root: this.options.root }),
|
||||
assetPlugin(),
|
||||
importMetaPlugin(),
|
||||
esmShimPlugin(),
|
||||
...configDrivenPlugins
|
||||
]
|
||||
: [
|
||||
electronPreloadConfigPresetPlugin({ root: this.options.root }),
|
||||
electronPreloadConfigValidatorPlugin(),
|
||||
assetPlugin(),
|
||||
importMetaPlugin(),
|
||||
esmShimPlugin(),
|
||||
...configDrivenPlugins,
|
||||
...(config.build?.isolatedEntries ? [isolateEntriesPlugin(this)] : [])
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
export class RendererConfigFactory extends ConfigFactory<RendererViteConfig> {
|
||||
protected processType(): 'renderer' {
|
||||
return 'renderer'
|
||||
}
|
||||
|
||||
protected async resolveBuiltinPlugins(config: RendererViteConfig, cleanMode?: boolean): Promise<PluginOption[]> {
|
||||
return cleanMode
|
||||
? [electronRendererConfigPresetPlugin({ root: this.options.root })]
|
||||
: [
|
||||
electronRendererConfigPresetPlugin({ root: this.options.root }),
|
||||
electronRendererConfigValidatorPlugin(),
|
||||
...(config.build?.isolatedEntries ? [isolateEntriesPlugin(this)] : [])
|
||||
]
|
||||
}
|
||||
function deepClone<T>(data: T): T {
|
||||
return JSON.parse(JSON.stringify(data))
|
||||
}
|
||||
|
||||
function resetOutDir(config: ViteConfig, outDir: string, subOutDir: string): void {
|
||||
@ -330,37 +224,12 @@ function resetOutDir(config: ViteConfig, outDir: string, subOutDir: string): voi
|
||||
}
|
||||
}
|
||||
|
||||
async function resolveConfigDrivenPlugins(config: MainViteConfig | PreloadViteConfig): Promise<PluginOption[]> {
|
||||
const userPlugins = (await asyncFlatten(config.plugins || [])).filter(Boolean) as Plugin[]
|
||||
|
||||
const configDrivenPlugins: PluginOption[] = []
|
||||
|
||||
const hasExternalizeDepsPlugin = userPlugins.some(p => p.name === 'vite:externalize-deps')
|
||||
if (!hasExternalizeDepsPlugin) {
|
||||
const externalOptions = config.build?.externalizeDeps ?? true
|
||||
if (externalOptions) {
|
||||
isOptions<ExternalOptions>(externalOptions)
|
||||
? configDrivenPlugins.push(externalizeDepsPlugin(externalOptions))
|
||||
: configDrivenPlugins.push(externalizeDepsPlugin())
|
||||
}
|
||||
function mergePlugins(config: ViteConfig, plugins: Plugin[]): void {
|
||||
const userPlugins = config.plugins || []
|
||||
config.plugins = userPlugins.concat(plugins)
|
||||
}
|
||||
|
||||
const hasBytecodePlugin = userPlugins.some(p => p.name === 'vite:bytecode')
|
||||
if (!hasBytecodePlugin) {
|
||||
const bytecodeOptions = config.build?.bytecode
|
||||
if (bytecodeOptions) {
|
||||
isOptions<BytecodeOptions>(bytecodeOptions)
|
||||
? configDrivenPlugins.push(bytecodePlugin(bytecodeOptions))
|
||||
: configDrivenPlugins.push(bytecodePlugin())
|
||||
}
|
||||
}
|
||||
|
||||
return configDrivenPlugins
|
||||
}
|
||||
|
||||
function isOptions<T extends object>(value: boolean | T): value is T {
|
||||
return typeof value === 'object' && value !== null
|
||||
}
|
||||
const CONFIG_FILE_NAME = 'electron.vite.config'
|
||||
|
||||
export async function loadConfigFromFile(
|
||||
configEnv: ConfigEnv,
|
||||
@ -377,7 +246,9 @@ export async function loadConfigFromFile(
|
||||
throw new Error(`config file cannot be named ${configFile}.`)
|
||||
}
|
||||
|
||||
const resolvedPath = configFile ? path.resolve(configFile) : findConfigFile(configRoot)
|
||||
const resolvedPath = configFile
|
||||
? path.resolve(configFile)
|
||||
: findConfigFile(configRoot, ['js', 'ts', 'mjs', 'cjs', 'mts', 'cts'])
|
||||
|
||||
if (!resolvedPath) {
|
||||
return {
|
||||
@ -390,30 +261,180 @@ export async function loadConfigFromFile(
|
||||
const isESM = isFilePathESM(resolvedPath)
|
||||
|
||||
try {
|
||||
const { code, dependencies } = await bundleConfigFile(resolvedPath, isESM)
|
||||
const configExport = await loadConfigFormBundledFile<ElectronViteConfigExport>(resolvedPath, code, isESM)
|
||||
const bundled = await bundleConfigFile(resolvedPath, isESM)
|
||||
const userConfig = await loadConfigFormBundledFile(configRoot, resolvedPath, bundled.code, isESM)
|
||||
|
||||
const config = await (typeof configExport === 'function' ? configExport(configEnv) : configExport)
|
||||
const config = await (typeof userConfig === 'function' ? userConfig(configEnv) : userConfig)
|
||||
if (!isObject(config)) {
|
||||
throw new Error(`config must export or return an object`)
|
||||
}
|
||||
|
||||
if (!ignoreConfigWarning) {
|
||||
const missingFields = ['main', 'renderer', 'preload'].filter(field => !config[field])
|
||||
if (missingFields.length > 0) {
|
||||
createLogger(logLevel).warn(
|
||||
`${colors.yellow(colors.bold('(!)'))} ${colors.yellow(`${missingFields.join(' and ')} config is missing`)}\n`
|
||||
)
|
||||
const configRequired: string[] = []
|
||||
|
||||
let mainConfig
|
||||
if (config.main) {
|
||||
const mainViteConfig = config.main
|
||||
mainConfig = await (typeof mainViteConfig === 'function' ? mainViteConfig(configEnv) : mainViteConfig)
|
||||
if (!isObject(mainConfig)) {
|
||||
throw new Error(`main config must export or return an object`)
|
||||
}
|
||||
} else {
|
||||
configRequired.push('main')
|
||||
}
|
||||
|
||||
let rendererConfig
|
||||
if (config.renderer) {
|
||||
const rendererViteConfig = config.renderer
|
||||
rendererConfig = await (typeof rendererViteConfig === 'function'
|
||||
? rendererViteConfig(configEnv)
|
||||
: rendererViteConfig)
|
||||
if (!isObject(rendererConfig)) {
|
||||
throw new Error(`renderer config must export or return an object`)
|
||||
}
|
||||
} else {
|
||||
configRequired.push('renderer')
|
||||
}
|
||||
|
||||
let preloadConfig
|
||||
if (config.preload) {
|
||||
const preloadViteConfig = config.preload
|
||||
preloadConfig = await (typeof preloadViteConfig === 'function' ? preloadViteConfig(configEnv) : preloadViteConfig)
|
||||
if (!isObject(preloadConfig)) {
|
||||
throw new Error(`preload config must export or return an object`)
|
||||
}
|
||||
} else {
|
||||
configRequired.push('preload')
|
||||
}
|
||||
|
||||
if (!ignoreConfigWarning && configRequired.length > 0) {
|
||||
createLogger(logLevel).warn(colors.yellow(`${configRequired.join(' and ')} config is missing`))
|
||||
}
|
||||
|
||||
return {
|
||||
path: normalizePath(resolvedPath),
|
||||
config,
|
||||
dependencies
|
||||
config: {
|
||||
main: mainConfig,
|
||||
renderer: rendererConfig,
|
||||
preload: preloadConfig
|
||||
},
|
||||
dependencies: bundled.dependencies
|
||||
}
|
||||
} catch (e) {
|
||||
createLogger(logLevel).error(colors.red(`failed to load config from ${resolvedPath}`), { error: e as Error })
|
||||
throw e
|
||||
}
|
||||
}
|
||||
|
||||
function findConfigFile(configRoot: string, extensions: string[]): string {
|
||||
for (const ext of extensions) {
|
||||
const configFile = path.resolve(configRoot, `${CONFIG_FILE_NAME}.${ext}`)
|
||||
if (fs.existsSync(configFile)) {
|
||||
return configFile
|
||||
}
|
||||
}
|
||||
return ''
|
||||
}
|
||||
|
||||
async function bundleConfigFile(fileName: string, isESM: boolean): Promise<{ code: string; dependencies: string[] }> {
|
||||
const dirnameVarName = '__electron_vite_injected_dirname'
|
||||
const filenameVarName = '__electron_vite_injected_filename'
|
||||
const importMetaUrlVarName = '__electron_vite_injected_import_meta_url'
|
||||
const result = await build({
|
||||
absWorkingDir: process.cwd(),
|
||||
entryPoints: [fileName],
|
||||
write: false,
|
||||
target: ['node20'],
|
||||
platform: 'node',
|
||||
bundle: true,
|
||||
format: isESM ? 'esm' : 'cjs',
|
||||
sourcemap: false,
|
||||
metafile: true,
|
||||
define: {
|
||||
__dirname: dirnameVarName,
|
||||
__filename: filenameVarName,
|
||||
'import.meta.url': importMetaUrlVarName
|
||||
},
|
||||
plugins: [
|
||||
{
|
||||
name: 'externalize-deps',
|
||||
setup(build): void {
|
||||
build.onResolve({ filter: /.*/ }, args => {
|
||||
const id = args.path
|
||||
if (id[0] !== '.' && !path.isAbsolute(id)) {
|
||||
return {
|
||||
external: true
|
||||
}
|
||||
}
|
||||
return null
|
||||
})
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'replace-import-meta',
|
||||
setup(build): void {
|
||||
build.onLoad({ filter: /\.[cm]?[jt]s$/ }, async args => {
|
||||
const contents = await fs.promises.readFile(args.path, 'utf8')
|
||||
const injectValues =
|
||||
`const ${dirnameVarName} = ${JSON.stringify(path.dirname(args.path))};` +
|
||||
`const ${filenameVarName} = ${JSON.stringify(args.path)};` +
|
||||
`const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(args.path).href)};`
|
||||
|
||||
return {
|
||||
loader: args.path.endsWith('ts') ? 'ts' : 'js',
|
||||
contents: injectValues + contents
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
]
|
||||
})
|
||||
const { text } = result.outputFiles[0]
|
||||
return {
|
||||
code: text,
|
||||
dependencies: result.metafile ? Object.keys(result.metafile.inputs) : []
|
||||
}
|
||||
}
|
||||
|
||||
interface NodeModuleWithCompile extends NodeModule {
|
||||
/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
|
||||
_compile(code: string, filename: string): any
|
||||
}
|
||||
|
||||
const _require = createRequire(import.meta.url)
|
||||
async function loadConfigFormBundledFile(
|
||||
configRoot: string,
|
||||
configFile: string,
|
||||
bundledCode: string,
|
||||
isESM: boolean
|
||||
): Promise<ElectronViteConfigExport> {
|
||||
if (isESM) {
|
||||
const fileNameTmp = path.resolve(configRoot, `${CONFIG_FILE_NAME}.${Date.now()}.mjs`)
|
||||
fs.writeFileSync(fileNameTmp, bundledCode)
|
||||
|
||||
const fileUrl = pathToFileURL(fileNameTmp)
|
||||
try {
|
||||
return (await import(fileUrl.href)).default
|
||||
} finally {
|
||||
try {
|
||||
fs.unlinkSync(fileNameTmp)
|
||||
// eslint-disable-next-line no-empty
|
||||
} catch {}
|
||||
}
|
||||
} else {
|
||||
const extension = path.extname(configFile)
|
||||
const realFileName = fs.realpathSync(configFile)
|
||||
const loaderExt = extension in _require.extensions ? extension : '.js'
|
||||
const defaultLoader = _require.extensions[loaderExt]!
|
||||
_require.extensions[loaderExt] = (module: NodeModule, filename: string): void => {
|
||||
if (filename === realFileName) {
|
||||
;(module as NodeModuleWithCompile)._compile(bundledCode, filename)
|
||||
} else {
|
||||
defaultLoader(module, filename)
|
||||
}
|
||||
}
|
||||
delete _require.cache[_require.resolve(configFile)]
|
||||
const raw = _require(configFile)
|
||||
_require.extensions[loaderExt] = defaultLoader
|
||||
return raw.__esModule ? raw.default : raw
|
||||
}
|
||||
}
|
||||
|
||||
@ -41,9 +41,9 @@ export function supportESM(): boolean {
|
||||
return parseInt(majorVer) >= 28
|
||||
}
|
||||
|
||||
export function supportImportMetaPaths(): boolean {
|
||||
export function getElectronMajorVersion(): number {
|
||||
const majorVer = getElectronMajorVer()
|
||||
return parseInt(majorVer) >= 30
|
||||
return parseInt(majorVer)
|
||||
}
|
||||
|
||||
export function getElectronPath(): string {
|
||||
@ -69,13 +69,6 @@ export function getElectronNodeTarget(): string {
|
||||
const electronVer = getElectronMajorVer()
|
||||
|
||||
const nodeVer = {
|
||||
'44': '24.18',
|
||||
'43': '24.17',
|
||||
'42': '24.15',
|
||||
'41': '24.14',
|
||||
'40': '24.14',
|
||||
'39': '22.20',
|
||||
'38': '22.19',
|
||||
'37': '22.16',
|
||||
'36': '22.14',
|
||||
'35': '22.14',
|
||||
@ -91,7 +84,11 @@ export function getElectronNodeTarget(): string {
|
||||
'25': '18.15',
|
||||
'24': '18.14',
|
||||
'23': '18.12',
|
||||
'22': '16.17'
|
||||
'22': '16.17',
|
||||
'21': '16.16',
|
||||
'20': '16.15',
|
||||
'19': '16.14',
|
||||
'18': '16.13'
|
||||
}
|
||||
if (electronVer && parseInt(electronVer) > 10) {
|
||||
let target = nodeVer[electronVer]
|
||||
@ -105,13 +102,6 @@ export function getElectronChromeTarget(): string {
|
||||
const electronVer = getElectronMajorVer()
|
||||
|
||||
const chromeVer = {
|
||||
'44': '152',
|
||||
'43': '150',
|
||||
'42': '148',
|
||||
'41': '146',
|
||||
'40': '144',
|
||||
'39': '142',
|
||||
'38': '140',
|
||||
'37': '138',
|
||||
'36': '136',
|
||||
'35': '134',
|
||||
@ -127,7 +117,11 @@ export function getElectronChromeTarget(): string {
|
||||
'25': '114',
|
||||
'24': '112',
|
||||
'23': '110',
|
||||
'22': '108'
|
||||
'22': '108',
|
||||
'21': '106',
|
||||
'20': '104',
|
||||
'19': '102',
|
||||
'18': '100'
|
||||
}
|
||||
if (electronVer && parseInt(electronVer) > 10) {
|
||||
let target = chromeVer[electronVer]
|
||||
@ -165,36 +159,7 @@ export function startElectron(root: string | undefined): ChildProcess {
|
||||
const entry = process.env.ELECTRON_ENTRY || '.'
|
||||
|
||||
const ps = spawn(electronPath, [entry].concat(args), { stdio: 'inherit' })
|
||||
// `code` is null when the child was terminated by a signal, and `process.exit` ignores
|
||||
// its second argument, so passing the listener directly would report every crash as a
|
||||
// successful exit. Map a signal death to a non-zero status instead.
|
||||
ps.on('close', (code, signal) => process.exit(code ?? (signal ? 1 : 0)))
|
||||
|
||||
setupElectronSignalHandlers(ps)
|
||||
ps.on('close', process.exit)
|
||||
|
||||
return ps
|
||||
}
|
||||
|
||||
let electronPs: ChildProcess | undefined
|
||||
let signalHandlersRegistered = false
|
||||
|
||||
function setupElectronSignalHandlers(child: ChildProcess): void {
|
||||
electronPs = child
|
||||
|
||||
if (signalHandlersRegistered) return
|
||||
|
||||
const signals: NodeJS.Signals[] =
|
||||
process.platform === 'win32' ? ['SIGINT', 'SIGTERM'] : ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGUSR2']
|
||||
|
||||
for (const signal of signals) {
|
||||
process.on(signal, () => {
|
||||
const child = electronPs
|
||||
if (!child?.pid || child.exitCode !== null || child.signalCode !== null) return
|
||||
|
||||
// A previously sent signal does not mean the child has exited.
|
||||
child.kill(signal)
|
||||
})
|
||||
}
|
||||
|
||||
signalHandlersRegistered = true
|
||||
}
|
||||
|
||||
130
src/load.ts
130
src/load.ts
@ -1,130 +0,0 @@
|
||||
import path from 'node:path'
|
||||
import fs from 'node:fs'
|
||||
import { pathToFileURL } from 'node:url'
|
||||
import { createRequire } from 'node:module'
|
||||
import { rolldown } from 'rolldown'
|
||||
import type { RolldownOutput, OutputChunk } from 'rolldown'
|
||||
|
||||
const CONFIG_FILE_NAME = 'electron.vite.config'
|
||||
|
||||
export function findConfigFile(
|
||||
configRoot: string,
|
||||
extensions: string[] = ['js', 'ts', 'mjs', 'cjs', 'mts', 'cts']
|
||||
): string {
|
||||
for (const ext of extensions) {
|
||||
const configFile = path.resolve(configRoot, `${CONFIG_FILE_NAME}.${ext}`)
|
||||
if (fs.existsSync(configFile)) {
|
||||
return configFile
|
||||
}
|
||||
}
|
||||
return ''
|
||||
}
|
||||
|
||||
export async function bundleConfigFile(
|
||||
fileName: string,
|
||||
isESM: boolean
|
||||
): Promise<{ code: string; dependencies: string[] }> {
|
||||
const dirnameVarName = '__electron_vite_injected_dirname'
|
||||
const filenameVarName = '__electron_vite_injected_filename'
|
||||
const importMetaUrlVarName = '__electron_vite_injected_import_meta_url'
|
||||
|
||||
const bundle = await rolldown({
|
||||
input: path.resolve(fileName),
|
||||
platform: 'node',
|
||||
transform: {
|
||||
target: 'node20',
|
||||
define: {
|
||||
__dirname: dirnameVarName,
|
||||
__filename: filenameVarName,
|
||||
'import.meta.url': importMetaUrlVarName
|
||||
}
|
||||
},
|
||||
plugins: [
|
||||
{
|
||||
name: 'externalize-deps',
|
||||
resolveId(id) {
|
||||
if (id[0] !== '.' && !path.isAbsolute(id)) {
|
||||
return { id, external: true }
|
||||
}
|
||||
return null
|
||||
}
|
||||
},
|
||||
{
|
||||
name: 'inject-file-scope-variables',
|
||||
transform: {
|
||||
filter: { id: /\.[cm]?[jt]s$/ },
|
||||
handler(code, id) {
|
||||
const injectValues =
|
||||
`const ${dirnameVarName} = ${JSON.stringify(path.dirname(id))};` +
|
||||
`const ${filenameVarName} = ${JSON.stringify(id)};` +
|
||||
`const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(id).href)};`
|
||||
return { code: injectValues + code, map: null }
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
})
|
||||
|
||||
let result: RolldownOutput
|
||||
try {
|
||||
result = await bundle.generate({
|
||||
format: isESM ? 'esm' : 'cjs',
|
||||
sourcemap: 'inline',
|
||||
sourcemapPathTransform(relative, sourcemapPath) {
|
||||
return path.resolve(path.dirname(sourcemapPath), relative)
|
||||
},
|
||||
codeSplitting: false
|
||||
})
|
||||
} finally {
|
||||
await bundle.close()
|
||||
}
|
||||
|
||||
const entryChunk = result.output.find((chunk): chunk is OutputChunk => chunk.type === 'chunk' && chunk.isEntry)
|
||||
if (!entryChunk) {
|
||||
throw new Error(`Failed to bundle config file: ${fileName}`)
|
||||
}
|
||||
|
||||
return {
|
||||
code: entryChunk.code,
|
||||
dependencies: entryChunk.moduleIds.filter(id => !id.startsWith('\0'))
|
||||
}
|
||||
}
|
||||
|
||||
interface NodeModuleWithCompile extends NodeModule {
|
||||
/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
|
||||
_compile(code: string, filename: string): any
|
||||
}
|
||||
|
||||
const _require = createRequire(import.meta.url)
|
||||
|
||||
export async function loadConfigFormBundledFile<T>(fileName: string, bundledCode: string, isESM: boolean): Promise<T> {
|
||||
if (isESM) {
|
||||
const fileNameTmp = `${fileName}.${Date.now()}-${Math.random().toString(16).slice(2)}.mjs`
|
||||
fs.writeFileSync(fileNameTmp, bundledCode)
|
||||
|
||||
const fileUrl = pathToFileURL(fileNameTmp)
|
||||
try {
|
||||
return (await import(fileUrl.href)).default
|
||||
} finally {
|
||||
try {
|
||||
fs.unlinkSync(fileNameTmp)
|
||||
} catch {}
|
||||
}
|
||||
} else {
|
||||
const extension = path.extname(fileName)
|
||||
const realFileName = fs.realpathSync(fileName)
|
||||
const loaderExt = extension in _require.extensions ? extension : '.js'
|
||||
const defaultLoader = _require.extensions[loaderExt]!
|
||||
_require.extensions[loaderExt] = (module: NodeModule, filename: string): void => {
|
||||
if (filename === realFileName) {
|
||||
;(module as NodeModuleWithCompile)._compile(bundledCode, filename)
|
||||
} else {
|
||||
defaultLoader(module, filename)
|
||||
}
|
||||
}
|
||||
delete _require.cache[_require.resolve(fileName)]
|
||||
const raw = _require(fileName)
|
||||
_require.extensions[loaderExt] = defaultLoader
|
||||
return raw.__esModule ? raw.default : raw
|
||||
}
|
||||
}
|
||||
@ -1,17 +1,50 @@
|
||||
import path from 'node:path'
|
||||
import fs from 'node:fs/promises'
|
||||
import { type Plugin, type Environment, normalizePath } from 'vite'
|
||||
import type { SourceMapInput } from 'rollup'
|
||||
import { type Plugin, normalizePath } from 'vite'
|
||||
import MagicString from 'magic-string'
|
||||
import { cleanUrl, getHash, toRelativePath } from '../utils'
|
||||
import { supportImportMetaPaths } from '../electron'
|
||||
import { cleanUrl, parseRequest, getHash, toRelativePath } from '../utils'
|
||||
|
||||
interface AssetResolved {
|
||||
type: 'asset' | 'native' | 'wasm'
|
||||
file: string
|
||||
query: Record<string, string> | null
|
||||
}
|
||||
|
||||
function resolveAsset(id: string): AssetResolved | null {
|
||||
const file = cleanUrl(id)
|
||||
const query = parseRequest(id)
|
||||
|
||||
if (query && typeof query.asset === 'string') {
|
||||
return {
|
||||
type: 'asset',
|
||||
file,
|
||||
query
|
||||
}
|
||||
}
|
||||
|
||||
if (file.endsWith('.node')) {
|
||||
return {
|
||||
type: 'native',
|
||||
file,
|
||||
query
|
||||
}
|
||||
}
|
||||
|
||||
if (id.endsWith('.wasm?loader')) {
|
||||
return {
|
||||
type: 'wasm',
|
||||
file,
|
||||
query
|
||||
}
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
const nodeAssetRE = /__VITE_NODE_ASSET__([\w$]+)__/g
|
||||
const nodePublicAssetRE = /__VITE_NODE_PUBLIC_ASSET__([a-z\d]{8})__/g
|
||||
|
||||
const assetImportRE = /(?:[?|&]asset(?:&|$)|\.wasm\?loader$|\.node$)/
|
||||
const assetRE = /[?|&]asset(?:&|$)/
|
||||
const assetUnpackRE = /[?|&]asset&asarUnpack$/
|
||||
|
||||
const wasmHelperId = '\0__electron-vite-wasm-helper'
|
||||
|
||||
const wasmHelperCode = `
|
||||
@ -25,18 +58,24 @@ export default async function loadWasm(file, importObject = {}) {
|
||||
}
|
||||
`
|
||||
|
||||
const assetCache = new WeakMap<Environment, Map<string, string>>()
|
||||
const publicAssetPathCache = new WeakMap<Environment, Map<string, string>>()
|
||||
|
||||
export default function assetPlugin(): Plugin {
|
||||
const isImportMetaPathSupported = supportImportMetaPaths()
|
||||
let sourcemap: boolean | 'inline' | 'hidden' = false
|
||||
let publicDir = ''
|
||||
let outDir = ''
|
||||
const publicAssetPathCache = new Map<string, string>()
|
||||
const assetCache = new Map<string, string>()
|
||||
return {
|
||||
name: 'vite:node-asset',
|
||||
apply: 'build',
|
||||
enforce: 'pre',
|
||||
buildStart(): void {
|
||||
publicAssetPathCache.set(this.environment, new Map())
|
||||
assetCache.set(this.environment, new Map())
|
||||
publicAssetPathCache.clear()
|
||||
assetCache.clear()
|
||||
},
|
||||
configResolved(config): void {
|
||||
sourcemap = config.build.sourcemap
|
||||
publicDir = normalizePath(config.publicDir)
|
||||
outDir = normalizePath(path.resolve(config.root, config.build.outDir))
|
||||
},
|
||||
resolveId(id): string | void {
|
||||
if (id === wasmHelperId) {
|
||||
@ -48,26 +87,27 @@ export default function assetPlugin(): Plugin {
|
||||
return wasmHelperCode
|
||||
}
|
||||
|
||||
if (id.startsWith('\0') || !assetImportRE.test(id)) {
|
||||
if (id.startsWith('\0')) {
|
||||
// Rollup convention, this id should be handled by the
|
||||
// plugin that marked it with \0
|
||||
return
|
||||
}
|
||||
|
||||
const assetResolved = resolveAsset(id)
|
||||
if (!assetResolved) {
|
||||
return
|
||||
}
|
||||
|
||||
let referenceId: string
|
||||
|
||||
const file = cleanUrl(id)
|
||||
|
||||
const { publicDir } = this.environment.config
|
||||
|
||||
const file = assetResolved.file
|
||||
if (publicDir && file.startsWith(publicDir)) {
|
||||
const hash = getHash(file)
|
||||
const publicAssetPathMap = publicAssetPathCache.get(this.environment)!
|
||||
if (!publicAssetPathMap.get(hash)) {
|
||||
publicAssetPathMap.set(hash, file)
|
||||
if (!publicAssetPathCache.get(hash)) {
|
||||
publicAssetPathCache.set(hash, file)
|
||||
}
|
||||
referenceId = `__VITE_NODE_PUBLIC_ASSET__${hash}__`
|
||||
} else {
|
||||
const cache = assetCache.get(this.environment)!
|
||||
const cached = cache.get(file)
|
||||
const cached = assetCache.get(file)
|
||||
if (cached) {
|
||||
referenceId = cached
|
||||
} else {
|
||||
@ -78,38 +118,38 @@ export default function assetPlugin(): Plugin {
|
||||
source: source as unknown as Uint8Array
|
||||
})
|
||||
referenceId = `__VITE_NODE_ASSET__${hash}__`
|
||||
cache.set(file, referenceId)
|
||||
assetCache.set(file, referenceId)
|
||||
}
|
||||
}
|
||||
|
||||
if (assetRE.test(id)) {
|
||||
const dirnameExpr = isImportMetaPathSupported ? 'import.meta.dirname' : '__dirname'
|
||||
if (assetUnpackRE.test(id)) {
|
||||
if (assetResolved.type === 'asset') {
|
||||
if (assetResolved.query && typeof assetResolved.query.asarUnpack === 'string') {
|
||||
return `
|
||||
import { join } from 'path'
|
||||
export default join(${dirnameExpr}, ${referenceId}).replace('app.asar', 'app.asar.unpacked')`
|
||||
export default join(__dirname, ${referenceId}).replace('app.asar', 'app.asar.unpacked')`
|
||||
} else {
|
||||
return `
|
||||
import { join } from 'path'
|
||||
export default join(${dirnameExpr}, ${referenceId})`
|
||||
export default join(__dirname, ${referenceId})`
|
||||
}
|
||||
}
|
||||
|
||||
if (id.endsWith('.node')) {
|
||||
if (assetResolved.type === 'native') {
|
||||
return `export default require(${referenceId})`
|
||||
}
|
||||
|
||||
if (id.endsWith('.wasm?loader')) {
|
||||
if (assetResolved.type === 'wasm') {
|
||||
return `
|
||||
import loadWasm from ${JSON.stringify(wasmHelperId)}
|
||||
export default importObject => loadWasm(${referenceId}, importObject)`
|
||||
}
|
||||
},
|
||||
renderChunk(code, chunk, { sourcemap, dir }) {
|
||||
renderChunk(code, chunk): { code: string; map: SourceMapInput } | null {
|
||||
let match: RegExpExecArray | null
|
||||
let s: MagicString | undefined
|
||||
|
||||
nodeAssetRE.lastIndex = 0
|
||||
if (code.match(nodeAssetRE)) {
|
||||
while ((match = nodeAssetRE.exec(code))) {
|
||||
s ||= new MagicString(code)
|
||||
const [full, hash] = match
|
||||
@ -120,29 +160,30 @@ export default function assetPlugin(): Plugin {
|
||||
contentOnly: true
|
||||
})
|
||||
}
|
||||
|
||||
const publicAssetPathMap = publicAssetPathCache.get(this.environment)!
|
||||
}
|
||||
|
||||
nodePublicAssetRE.lastIndex = 0
|
||||
if (code.match(nodePublicAssetRE)) {
|
||||
while ((match = nodePublicAssetRE.exec(code))) {
|
||||
s ||= new MagicString(code)
|
||||
const [full, hash] = match
|
||||
const filename = publicAssetPathMap.get(hash)!
|
||||
const outputFilepath = toRelativePath(filename, normalizePath(path.join(dir!, chunk.fileName)))
|
||||
const filename = publicAssetPathCache.get(hash)!
|
||||
const outputFilepath = toRelativePath(filename, normalizePath(path.join(outDir, chunk.fileName)))
|
||||
const replacement = JSON.stringify(outputFilepath)
|
||||
s.overwrite(match.index, match.index + full.length, replacement, {
|
||||
contentOnly: true
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
if (s) {
|
||||
return {
|
||||
code: s.toString(),
|
||||
map: sourcemap ? s.generateMap({ hires: 'boundary' }) : null
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
return null
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,89 +1,155 @@
|
||||
import path from 'node:path'
|
||||
import { randomBytes } from 'node:crypto'
|
||||
import fs from 'node:fs'
|
||||
import { spawn } from 'node:child_process'
|
||||
import { createRequire } from 'node:module'
|
||||
import colors from 'picocolors'
|
||||
import { type Plugin, type Rolldown, normalizePath } from 'vite'
|
||||
import type * as Babel from '@babel/core'
|
||||
import { type Plugin, type ResolvedConfig, normalizePath, createFilter } from 'vite'
|
||||
import * as babel from '@babel/core'
|
||||
import MagicString from 'magic-string'
|
||||
import { toRelativePath, resolveBuildOutputs } from '../utils'
|
||||
import type { BytecodeCompiler, BytecodeTarget } from '../bytecodeCompiler'
|
||||
import type { SourceMapInput, OutputChunk } from 'rollup'
|
||||
import { getElectronPath } from '../electron'
|
||||
import { toRelativePath } from '../utils'
|
||||
|
||||
// Inspired by https://github.com/bytenode/bytenode
|
||||
|
||||
const require = createRequire(import.meta.url)
|
||||
let babel: typeof Babel | undefined
|
||||
const _require = createRequire(import.meta.url)
|
||||
|
||||
function getBytecodeCompiler(plugins: readonly Plugin[]): BytecodeCompiler | undefined {
|
||||
const plugin = plugins.find(plugin => plugin.name === 'vite:electron-bytecode-build')
|
||||
return (plugin?.api as { compiler?: BytecodeCompiler } | undefined)?.compiler
|
||||
function getBytecodeCompilerPath(): string {
|
||||
return path.join(path.dirname(_require.resolve('electron-vite/package.json')), 'bin', 'electron-bytecode.cjs')
|
||||
}
|
||||
|
||||
// Versioned envelope: magic/version (8), UTF-16 source length (4), module ID (16), V8 cache.
|
||||
// Keep our metadata separate from the private V8 cache header.
|
||||
async function compileToBytecode(compiler: BytecodeCompiler, target: BytecodeTarget, code: string): Promise<Buffer> {
|
||||
const id = randomBytes(16)
|
||||
// Reserve enough source space for an untruncated, per-artifact placeholder identity.
|
||||
const source = code + '\n/*' + id.toString('hex') + '*/'
|
||||
const result = await compiler.compile(target, source)
|
||||
const header = Buffer.alloc(28)
|
||||
header.write('EVBC0001', 0, 'ascii')
|
||||
header.writeUInt32LE(result.sourceLength, 8)
|
||||
id.copy(header, 12)
|
||||
return Buffer.concat([header, Buffer.from(result.cachedData, 'base64')])
|
||||
function compileToBytecode(code: string): Promise<Buffer> {
|
||||
return new Promise((resolve, reject) => {
|
||||
let data = Buffer.from([])
|
||||
|
||||
const electronPath = getElectronPath()
|
||||
const bytecodePath = getBytecodeCompilerPath()
|
||||
|
||||
const proc = spawn(electronPath, [bytecodePath], {
|
||||
env: { ELECTRON_RUN_AS_NODE: '1' },
|
||||
stdio: ['pipe', 'pipe', 'pipe', 'ipc']
|
||||
})
|
||||
|
||||
if (proc.stdin) {
|
||||
proc.stdin.write(code)
|
||||
proc.stdin.end()
|
||||
}
|
||||
|
||||
if (proc.stdout) {
|
||||
proc.stdout.on('data', chunk => {
|
||||
data = Buffer.concat([data, chunk])
|
||||
})
|
||||
proc.stdout.on('error', err => {
|
||||
console.error(err)
|
||||
})
|
||||
proc.stdout.on('end', () => {
|
||||
resolve(data)
|
||||
})
|
||||
}
|
||||
|
||||
if (proc.stderr) {
|
||||
proc.stderr.on('data', chunk => {
|
||||
console.error('Error: ', chunk.toString())
|
||||
})
|
||||
proc.stderr.on('error', err => {
|
||||
console.error('Error: ', err)
|
||||
})
|
||||
}
|
||||
|
||||
proc.addListener('message', message => console.log(message))
|
||||
proc.addListener('error', err => console.error(err))
|
||||
|
||||
proc.on('error', err => reject(err))
|
||||
proc.on('exit', () => {
|
||||
resolve(data)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
const bytecodeModuleLoaderCode = [
|
||||
'"use strict";',
|
||||
'const fs = require("node:fs");',
|
||||
'const path = require("node:path");',
|
||||
'const vm = require("node:vm");',
|
||||
'const v8 = require("node:v8");',
|
||||
'const Module = require("node:module");',
|
||||
'v8.setFlagsFromString("--no-lazy");',
|
||||
'v8.setFlagsFromString("--no-flush-bytecode");',
|
||||
'const params = ["exports", "require", "module", "__filename", "__dirname"];',
|
||||
'Module._extensions[".jsc"] = Module._extensions[".cjsc"] = function (module, filename) {',
|
||||
' const data = fs.readFileSync(filename);',
|
||||
' if (data.length <= 28 || data.toString("ascii", 0, 8) !== "EVBC0001") {',
|
||||
' throw new Error("Invalid electron-vite bytecode format; rebuild the application: " + filename);',
|
||||
' }',
|
||||
' const length = data.readUInt32LE(8);',
|
||||
' const tag = "/*" + data.subarray(12, 28).toString("hex") + "*/";',
|
||||
' if (length < tag.length || length > 0x1fffffff) {',
|
||||
' throw new Error("Invalid bytecode source length: " + filename);',
|
||||
' }',
|
||||
' const placeholder = tag + " ".repeat(length - tag.length);',
|
||||
' const compiledWrapper = vm.compileFunction(placeholder, params, {',
|
||||
' filename,',
|
||||
' cachedData: data.subarray(28)',
|
||||
' });',
|
||||
' if (compiledWrapper.cachedDataRejected) {',
|
||||
' throw new Error("Invalid or incompatible cached data (cachedDataRejected): " + filename);',
|
||||
' }',
|
||||
' const require = function (id) { return module.require(id); };',
|
||||
' require.resolve = function (request, options) {',
|
||||
' return Module._resolveFilename(request, module, false, options);',
|
||||
' };',
|
||||
' if (process.mainModule) require.main = process.mainModule;',
|
||||
' require.extensions = Module._extensions;',
|
||||
' require.cache = Module._cache;',
|
||||
' return compiledWrapper.call(module.exports, module.exports, require, module, filename, path.dirname(filename));',
|
||||
'};'
|
||||
`"use strict";`,
|
||||
`const fs = require("fs");`,
|
||||
`const path = require("path");`,
|
||||
`const vm = require("vm");`,
|
||||
`const v8 = require("v8");`,
|
||||
`const Module = require("module");`,
|
||||
`v8.setFlagsFromString("--no-lazy");`,
|
||||
`v8.setFlagsFromString("--no-flush-bytecode");`,
|
||||
`const FLAG_HASH_OFFSET = 12;`,
|
||||
`const SOURCE_HASH_OFFSET = 8;`,
|
||||
`let dummyBytecode;`,
|
||||
`function setFlagHashHeader(bytecodeBuffer) {`,
|
||||
` if (!dummyBytecode) {`,
|
||||
` const script = new vm.Script("", {`,
|
||||
` produceCachedData: true`,
|
||||
` });`,
|
||||
` dummyBytecode = script.createCachedData();`,
|
||||
` }`,
|
||||
` dummyBytecode.slice(FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4).copy(bytecodeBuffer, FLAG_HASH_OFFSET);`,
|
||||
`};`,
|
||||
`function getSourceHashHeader(bytecodeBuffer) {`,
|
||||
` return bytecodeBuffer.slice(SOURCE_HASH_OFFSET, SOURCE_HASH_OFFSET + 4);`,
|
||||
`};`,
|
||||
`function buffer2Number(buffer) {`,
|
||||
` let ret = 0;`,
|
||||
` ret |= buffer[3] << 24;`,
|
||||
` ret |= buffer[2] << 16;`,
|
||||
` ret |= buffer[1] << 8;`,
|
||||
` ret |= buffer[0];`,
|
||||
` return ret;`,
|
||||
`};`,
|
||||
`Module._extensions[".jsc"] = Module._extensions[".cjsc"] = function (module, filename) {`,
|
||||
` const bytecodeBuffer = fs.readFileSync(filename);`,
|
||||
` if (!Buffer.isBuffer(bytecodeBuffer)) {`,
|
||||
` throw new Error("BytecodeBuffer must be a buffer object.");`,
|
||||
` }`,
|
||||
` setFlagHashHeader(bytecodeBuffer);`,
|
||||
` const length = buffer2Number(getSourceHashHeader(bytecodeBuffer));`,
|
||||
` let dummyCode = "";`,
|
||||
` if (length > 1) {`,
|
||||
` dummyCode = "\\"" + "\\u200b".repeat(length - 2) + "\\"";`,
|
||||
` }`,
|
||||
` const script = new vm.Script(dummyCode, {`,
|
||||
` filename: filename,`,
|
||||
` lineOffset: 0,`,
|
||||
` displayErrors: true,`,
|
||||
` cachedData: bytecodeBuffer`,
|
||||
` });`,
|
||||
` if (script.cachedDataRejected) {`,
|
||||
` throw new Error("Invalid or incompatible cached data (cachedDataRejected)");`,
|
||||
` }`,
|
||||
` const require = function (id) {`,
|
||||
` return module.require(id);`,
|
||||
` };`,
|
||||
` require.resolve = function (request, options) {`,
|
||||
` return Module._resolveFilename(request, module, false, options);`,
|
||||
` };`,
|
||||
` if (process.mainModule) {`,
|
||||
` require.main = process.mainModule;`,
|
||||
` }`,
|
||||
` require.extensions = Module._extensions;`,
|
||||
` require.cache = Module._cache;`,
|
||||
` const compiledWrapper = script.runInThisContext({`,
|
||||
` filename: filename,`,
|
||||
` lineOffset: 0,`,
|
||||
` columnOffset: 0,`,
|
||||
` displayErrors: true`,
|
||||
` });`,
|
||||
` const dirname = path.dirname(filename);`,
|
||||
` const args = [module.exports, require, module, filename, dirname, process, global];`,
|
||||
` return compiledWrapper.apply(module.exports, args);`,
|
||||
`};`
|
||||
]
|
||||
|
||||
const bytecodeChunkExtensionRE = /.(jsc|cjsc)$/
|
||||
|
||||
export interface BytecodeOptions {
|
||||
chunkAlias?: string | string[] | RegExp
|
||||
chunkAlias?: string | string[]
|
||||
transformArrowFunctions?: boolean
|
||||
removeBundleJS?: boolean
|
||||
protectedStrings?: string[]
|
||||
}
|
||||
|
||||
/**
|
||||
* Compile source code to v8 bytecode.
|
||||
*
|
||||
* @deprecated use `build.bytecode` config option instead
|
||||
* Compile to v8 bytecode to protect source code.
|
||||
*/
|
||||
export function bytecodePlugin(options: BytecodeOptions = {}): Plugin | null {
|
||||
if (process.env.NODE_ENV_ELECTRON_VITE !== 'production') {
|
||||
@ -91,152 +157,176 @@ export function bytecodePlugin(options: BytecodeOptions = {}): Plugin | null {
|
||||
}
|
||||
|
||||
const { chunkAlias = [], transformArrowFunctions = true, removeBundleJS = true, protectedStrings = [] } = options
|
||||
const _chunkAlias = chunkAlias instanceof RegExp ? chunkAlias : Array.isArray(chunkAlias) ? chunkAlias : [chunkAlias]
|
||||
const _chunkAlias = Array.isArray(chunkAlias) ? chunkAlias : [chunkAlias]
|
||||
|
||||
const filter = createFilter(/\.(m?[jt]s|[jt]sx)$/)
|
||||
|
||||
const escapeRegExpString = (str: string): string => {
|
||||
return str
|
||||
.replace(/\\/g, '\\\\\\\\')
|
||||
.replace(/[|{}()[\]^$+*?.]/g, '\\$&')
|
||||
.replace(/-/g, '\\u002d')
|
||||
}
|
||||
|
||||
const transformAllChunks = _chunkAlias.length === 0
|
||||
const isBytecodeChunk = (chunkName: string): boolean => {
|
||||
if (_chunkAlias instanceof RegExp) {
|
||||
_chunkAlias.lastIndex = 0
|
||||
return _chunkAlias.test(chunkName)
|
||||
}
|
||||
return _chunkAlias.length === 0 || _chunkAlias.some(alias => alias === chunkName)
|
||||
return transformAllChunks || _chunkAlias.some(alias => alias === chunkName)
|
||||
}
|
||||
|
||||
const plugins: Babel.PluginItem[] = []
|
||||
|
||||
if (transformArrowFunctions) {
|
||||
plugins.push('@babel/plugin-transform-arrow-functions')
|
||||
}
|
||||
|
||||
if (protectedStrings.length > 0) {
|
||||
plugins.push([protectStringsPlugin as Babel.PluginTarget, { protectedStrings: new Set(protectedStrings) }])
|
||||
}
|
||||
|
||||
const shouldTransformBytecodeChunk = plugins.length !== 0
|
||||
|
||||
const _transform = (
|
||||
code: string,
|
||||
sourceMaps: boolean = false
|
||||
): { code: string; map?: Rolldown.SourceMapInput } | null => {
|
||||
babel ??= require('@babel/core') as typeof Babel
|
||||
const re = babel.transformSync(code, { plugins, sourceMaps })
|
||||
return re ? { code: re.code || '', map: re.map as Rolldown.SourceMapInput } : null
|
||||
const _transform = (code: string): string => {
|
||||
const re = babel.transform(code, {
|
||||
plugins: ['@babel/plugin-transform-arrow-functions']
|
||||
})
|
||||
return re.code || ''
|
||||
}
|
||||
|
||||
const useStrict = '"use strict";'
|
||||
const bytecodeModuleLoader = 'bytecode-loader.cjs'
|
||||
|
||||
let supported = false
|
||||
let isPreload = false
|
||||
let bytecodeCompiler: BytecodeCompiler | undefined
|
||||
let config: ResolvedConfig
|
||||
let useInRenderer = false
|
||||
let bytecodeRequired = false
|
||||
let bytecodeFiles: { name: string; size: number }[] = []
|
||||
|
||||
return {
|
||||
name: 'vite:bytecode',
|
||||
apply: 'build',
|
||||
enforce: 'post',
|
||||
configResolved(config): void {
|
||||
bytecodeCompiler = getBytecodeCompiler(config.plugins)
|
||||
if (supported) {
|
||||
return
|
||||
}
|
||||
isPreload = config.plugins.some(p => p.name === 'vite:electron-preload-config-preset')
|
||||
const useInRenderer = config.plugins.some(p => p.name === 'vite:electron-renderer-config-preset')
|
||||
configResolved(resolvedConfig): void {
|
||||
config = resolvedConfig
|
||||
useInRenderer = config.plugins.some(p => p.name === 'vite:electron-renderer-preset-config')
|
||||
if (useInRenderer) {
|
||||
config.logger.warn(colors.yellow('bytecodePlugin does not support renderer.'))
|
||||
return
|
||||
}
|
||||
const build = config.build
|
||||
const outputs = resolveBuildOutputs(build.rolldownOptions.output, build.lib)
|
||||
const output = outputs[0]
|
||||
if (output) {
|
||||
if (output.format === 'es') {
|
||||
if (resolvedConfig.build.minify && protectedStrings.length > 0) {
|
||||
config.logger.warn(colors.yellow('Strings cannot be protected when minification is enabled.'))
|
||||
}
|
||||
},
|
||||
transform(code, id): void | { code: string; map: SourceMapInput } {
|
||||
if (config.build.minify || protectedStrings.length === 0 || !filter(id)) return
|
||||
|
||||
let match: RegExpExecArray | null
|
||||
let s: MagicString | undefined
|
||||
|
||||
protectedStrings.forEach(str => {
|
||||
const escapedStr = escapeRegExpString(str)
|
||||
const re = new RegExp(`\\u0027${escapedStr}\\u0027|\\u0022${escapedStr}\\u0022`, 'g')
|
||||
const charCodes = Array.from(str).map(s => s.charCodeAt(0))
|
||||
const replacement = `String.fromCharCode(${charCodes.toString()})`
|
||||
while ((match = re.exec(code))) {
|
||||
s ||= new MagicString(code)
|
||||
const [full] = match
|
||||
s.overwrite(match.index, match.index + full.length, replacement, {
|
||||
contentOnly: true
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
if (s) {
|
||||
return {
|
||||
code: s.toString(),
|
||||
map: config.build.sourcemap ? s.generateMap({ hires: 'boundary' }) : null
|
||||
}
|
||||
}
|
||||
},
|
||||
renderChunk(code, chunk, options): { code: string } | null {
|
||||
if (options.format === 'es') {
|
||||
config.logger.warn(
|
||||
colors.yellow(
|
||||
'bytecodePlugin does not support ES module, please remove "type": "module" ' +
|
||||
'in package.json or set build.rollupOptions.output.format (or build.rolldownOptions.output.format) to "cjs".'
|
||||
'in package.json or set the "build.rollupOptions.output.format" option to "cjs".'
|
||||
)
|
||||
)
|
||||
return null
|
||||
}
|
||||
if (useInRenderer) {
|
||||
return null
|
||||
}
|
||||
if (chunk.type === 'chunk' && isBytecodeChunk(chunk.name)) {
|
||||
bytecodeRequired = true
|
||||
if (transformArrowFunctions) {
|
||||
return {
|
||||
code: _transform(code)
|
||||
}
|
||||
supported = output.format === 'cjs' && !useInRenderer
|
||||
}
|
||||
},
|
||||
renderChunk(code, chunk, { sourcemap }): { code: string; map?: Rolldown.SourceMapInput } | null {
|
||||
if (supported && isBytecodeChunk(chunk.name) && shouldTransformBytecodeChunk) {
|
||||
return _transform(code, !!sourcemap)
|
||||
}
|
||||
return null
|
||||
},
|
||||
async generateBundle(_, output): Promise<void> {
|
||||
if (!supported) {
|
||||
return
|
||||
generateBundle(options): void {
|
||||
if (options.format !== 'es' && !useInRenderer && bytecodeRequired) {
|
||||
this.emitFile({
|
||||
type: 'asset',
|
||||
source: bytecodeModuleLoaderCode.join('\n') + '\n',
|
||||
name: 'Bytecode Loader File',
|
||||
fileName: bytecodeModuleLoader
|
||||
})
|
||||
}
|
||||
const _chunks = Object.values(output)
|
||||
const chunks = _chunks.filter(
|
||||
chunk => chunk.type === 'chunk' && isBytecodeChunk(chunk.name)
|
||||
) as Rolldown.OutputChunk[]
|
||||
|
||||
if (chunks.length === 0) {
|
||||
},
|
||||
async writeBundle(options, output): Promise<void> {
|
||||
if (options.format === 'es' || useInRenderer || !bytecodeRequired) {
|
||||
return
|
||||
}
|
||||
|
||||
const outDir = options.dir!
|
||||
|
||||
bytecodeFiles = []
|
||||
|
||||
const bundles = Object.keys(output)
|
||||
const chunks = Object.values(output).filter(
|
||||
chunk => chunk.type === 'chunk' && isBytecodeChunk(chunk.name) && chunk.fileName !== bytecodeModuleLoader
|
||||
) as OutputChunk[]
|
||||
const bytecodeChunks = chunks.map(chunk => chunk.fileName)
|
||||
const nonEntryChunks = chunks.filter(chunk => !chunk.isEntry).map(chunk => path.basename(chunk.fileName))
|
||||
|
||||
const pattern = nonEntryChunks.map(chunk => `(${chunk})`).join('|')
|
||||
const bytecodeRE = pattern ? new RegExp(`require\\(\\S*(?=(${pattern})\\S*\\))`, 'g') : null
|
||||
|
||||
const keepBundle = (chunkFileName: string): void => {
|
||||
const newFileName = path.resolve(path.dirname(chunkFileName), `_${path.basename(chunkFileName)}`)
|
||||
fs.renameSync(chunkFileName, newFileName)
|
||||
}
|
||||
|
||||
const getBytecodeLoaderBlock = (chunkFileName: string): string => {
|
||||
return `require("${toRelativePath(bytecodeModuleLoader, normalizePath(chunkFileName))}");`
|
||||
}
|
||||
|
||||
let bytecodeChunkCount = 0
|
||||
|
||||
const bundles = Object.keys(output)
|
||||
|
||||
if (!bytecodeCompiler) {
|
||||
throw new Error('Bytecode compilation requires an electron-vite build')
|
||||
}
|
||||
for (const name of bundles) {
|
||||
await Promise.all(
|
||||
bundles.map(async name => {
|
||||
const chunk = output[name]
|
||||
if (chunk.type === 'chunk') {
|
||||
let _code = chunk.code
|
||||
if (bytecodeRE) {
|
||||
if (bytecodeRE && _code.match(bytecodeRE)) {
|
||||
let match: RegExpExecArray | null
|
||||
let s: MagicString | undefined
|
||||
const s = new MagicString(_code)
|
||||
while ((match = bytecodeRE.exec(_code))) {
|
||||
s ||= new MagicString(_code)
|
||||
const [prefix, chunkName] = match
|
||||
const len = prefix.length + chunkName.length
|
||||
s.overwrite(match.index, match.index + len, prefix + chunkName + 'c', {
|
||||
contentOnly: true
|
||||
})
|
||||
}
|
||||
if (s) {
|
||||
_code = s.toString()
|
||||
}
|
||||
}
|
||||
const chunkFileName = path.resolve(outDir, name)
|
||||
if (bytecodeChunks.includes(name)) {
|
||||
const bytecodeBuffer = await compileToBytecode(bytecodeCompiler, isPreload ? 'preload' : 'main', _code)
|
||||
this.emitFile({
|
||||
type: 'asset',
|
||||
fileName: name + 'c',
|
||||
source: bytecodeBuffer
|
||||
})
|
||||
if (!removeBundleJS) {
|
||||
this.emitFile({
|
||||
type: 'asset',
|
||||
fileName: '_' + chunk.fileName,
|
||||
source: chunk.code
|
||||
})
|
||||
}
|
||||
const bytecodeBuffer = await compileToBytecode(_code)
|
||||
fs.writeFileSync(path.resolve(outDir, name + 'c'), bytecodeBuffer as unknown as Uint8Array)
|
||||
if (chunk.isEntry) {
|
||||
if (!removeBundleJS) {
|
||||
keepBundle(chunkFileName)
|
||||
}
|
||||
const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName)
|
||||
const bytecodeModuleBlock = `require("./${path.basename(name) + 'c'}");`
|
||||
const code = `${useStrict}\n${bytecodeLoaderBlock}\n${bytecodeModuleBlock}\n`
|
||||
chunk.code = code
|
||||
fs.writeFileSync(chunkFileName, code)
|
||||
} else {
|
||||
delete output[chunk.fileName]
|
||||
if (removeBundleJS) {
|
||||
fs.unlinkSync(chunkFileName)
|
||||
} else {
|
||||
keepBundle(chunkFileName)
|
||||
}
|
||||
bytecodeChunkCount += 1
|
||||
}
|
||||
bytecodeFiles.push({ name: name + 'c', size: bytecodeBuffer.length })
|
||||
} else {
|
||||
if (chunk.isEntry) {
|
||||
let hasBytecodeMoudle = false
|
||||
@ -247,113 +337,42 @@ export function bytecodePlugin(options: BytecodeOptions = {}): Plugin | null {
|
||||
break
|
||||
}
|
||||
const moduleInfo = this.getModuleInfo(moduleId)
|
||||
if (moduleInfo) {
|
||||
if (moduleInfo && !moduleInfo.isExternal) {
|
||||
const { importers, dynamicImporters } = moduleInfo
|
||||
for (const importerId of importers) idsToHandle.add(importerId)
|
||||
for (const importerId of dynamicImporters) idsToHandle.add(importerId)
|
||||
}
|
||||
}
|
||||
if (hasBytecodeMoudle) {
|
||||
const loader = getBytecodeLoaderBlock(chunk.fileName)
|
||||
const strictRE = /^(#![^\n]*\n)?(["'])use strict\2;/
|
||||
_code = strictRE.test(_code)
|
||||
? _code.replace(strictRE, `$&\n${loader}`)
|
||||
: _code.replace(/^(#![^\n]*\n)?/, `$&${loader}\n`)
|
||||
const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName)
|
||||
_code = hasBytecodeMoudle
|
||||
? _code.replace(/("use strict";)|('use strict';)/, `${useStrict}\n${bytecodeLoaderBlock}`)
|
||||
: _code
|
||||
}
|
||||
fs.writeFileSync(chunkFileName, _code)
|
||||
}
|
||||
}
|
||||
chunk.code = _code
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (bytecodeChunkCount && !_chunks.some(ass => ass.type === 'asset' && ass.fileName === bytecodeModuleLoader)) {
|
||||
this.emitFile({
|
||||
type: 'asset',
|
||||
source: bytecodeModuleLoaderCode.join('\n') + '\n',
|
||||
name: 'Bytecode Loader File',
|
||||
fileName: bytecodeModuleLoader
|
||||
})
|
||||
}
|
||||
)
|
||||
},
|
||||
writeBundle(_, output): void {
|
||||
if (supported) {
|
||||
const bytecodeChunkCount = Object.keys(output).filter(chunk => bytecodeChunkExtensionRE.test(chunk)).length
|
||||
this.environment.logger.info(`${colors.green(`✓`)} ${bytecodeChunkCount} chunks compiled into bytecode.`)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
interface ProtectStringsPluginState extends Babel.PluginPass {
|
||||
opts: { protectedStrings: Set<string> }
|
||||
}
|
||||
|
||||
function protectStringsPlugin(api: typeof Babel & Babel.ConfigAPI): Babel.PluginObj<ProtectStringsPluginState> {
|
||||
const { types: t } = api
|
||||
|
||||
function createFromCharCodeFunction(value: string): Babel.types.CallExpression {
|
||||
const charCodes = Array.from(value).map(s => s.charCodeAt(0))
|
||||
const charCodeLiterals = charCodes.map(code => t.numericLiteral(code))
|
||||
|
||||
// String.fromCharCode
|
||||
const memberExpression = t.memberExpression(t.identifier('String'), t.identifier('fromCharCode'))
|
||||
// String.fromCharCode(...arr)
|
||||
const callExpression = t.callExpression(memberExpression, [t.spreadElement(t.identifier('arr'))])
|
||||
// return String.fromCharCode(...arr)
|
||||
const returnStatement = t.returnStatement(callExpression)
|
||||
// function (arr) { return ... }
|
||||
const functionExpression = t.functionExpression(null, [t.identifier('arr')], t.blockStatement([returnStatement]))
|
||||
|
||||
// (function(...) { ... })([x, x, x])
|
||||
return t.callExpression(functionExpression, [t.arrayExpression(charCodeLiterals)])
|
||||
}
|
||||
|
||||
return {
|
||||
name: 'protect-strings-plugin',
|
||||
visitor: {
|
||||
StringLiteral(path, state) {
|
||||
// obj['property']
|
||||
if (path.parentPath.isMemberExpression({ property: path.node, computed: true })) {
|
||||
return
|
||||
}
|
||||
|
||||
// { 'key': value }
|
||||
if (path.parentPath.isObjectProperty({ key: path.node, computed: false })) {
|
||||
return
|
||||
}
|
||||
|
||||
// require('fs')
|
||||
if (
|
||||
path.parentPath.isCallExpression() &&
|
||||
t.isIdentifier(path.parentPath.node.callee) &&
|
||||
path.parentPath.node.callee.name === 'require' &&
|
||||
path.parentPath.node.arguments[0] === path.node
|
||||
) {
|
||||
return
|
||||
}
|
||||
|
||||
// Only CommonJS is supported, import declaration and export declaration checks are ignored
|
||||
|
||||
const { value } = path.node
|
||||
if (state.opts.protectedStrings.has(value)) {
|
||||
path.replaceWith(createFromCharCodeFunction(value))
|
||||
}
|
||||
},
|
||||
TemplateLiteral(path, state) {
|
||||
// Must be a pure static template literal
|
||||
// expressions must be empty (no ${variables})
|
||||
// quasis must have only one element (meaning the entire string is a single static part).
|
||||
if (path.node.expressions.length > 0 || path.node.quasis.length !== 1) {
|
||||
return
|
||||
}
|
||||
|
||||
// Extract the raw value of the template literal
|
||||
// path.node.quasis[0].value.raw is used to get the raw string, including escape sequences
|
||||
// path.node.quasis[0].value.cooked is used to get the processed/cooked string (with escape sequences handled)
|
||||
const value = path.node.quasis[0].value.cooked
|
||||
if (value && state.opts.protectedStrings.has(value)) {
|
||||
path.replaceWith(createFromCharCodeFunction(value))
|
||||
}
|
||||
closeBundle(): void {
|
||||
if (!useInRenderer) {
|
||||
const chunkLimit = config.build.chunkSizeWarningLimit
|
||||
const outDir = normalizePath(path.relative(config.root, path.resolve(config.root, config.build.outDir))) + '/'
|
||||
config.logger.info(`${colors.green(`✓`)} ${bytecodeFiles.length} bundles compiled into bytecode.`)
|
||||
let longest = 0
|
||||
bytecodeFiles.forEach(file => {
|
||||
const len = file.name.length
|
||||
if (len > longest) longest = len
|
||||
})
|
||||
bytecodeFiles.forEach(file => {
|
||||
const kbs = file.size / 1000
|
||||
config.logger.info(
|
||||
`${colors.gray(colors.white(colors.dim(outDir)))}${colors.green(file.name.padEnd(longest + 2))} ${
|
||||
kbs > chunkLimit ? colors.yellow(`${kbs.toFixed(2)} kB`) : colors.dim(`${kbs.toFixed(2)} kB`)
|
||||
}`
|
||||
)
|
||||
})
|
||||
bytecodeFiles = []
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -2,9 +2,10 @@ import path from 'node:path'
|
||||
import fs from 'node:fs'
|
||||
import { builtinModules } from 'node:module'
|
||||
import colors from 'picocolors'
|
||||
import { type Plugin, type UserConfig, mergeConfig, normalizePath } from 'vite'
|
||||
import { type Plugin, type LibraryOptions, mergeConfig, normalizePath } from 'vite'
|
||||
import type { OutputOptions } from 'rollup'
|
||||
import { getElectronNodeTarget, getElectronChromeTarget, supportESM } from '../electron'
|
||||
import { loadPackageData, resolveBuildOutputs } from '../utils'
|
||||
import { loadPackageData } from '../utils'
|
||||
|
||||
export interface ElectronPluginOptions {
|
||||
root?: string
|
||||
@ -38,9 +39,21 @@ function processEnvDefine(): Record<string, string> {
|
||||
}
|
||||
}
|
||||
|
||||
export function electronMainConfigPresetPlugin(options?: ElectronPluginOptions): Plugin {
|
||||
return {
|
||||
name: 'vite:electron-main-config-preset',
|
||||
function resolveBuildOutputs(
|
||||
outputs: OutputOptions | OutputOptions[] | undefined,
|
||||
libOptions: LibraryOptions | false
|
||||
): OutputOptions | OutputOptions[] | undefined {
|
||||
if (libOptions && !Array.isArray(outputs)) {
|
||||
const libFormats = libOptions.formats || []
|
||||
return libFormats.map(format => ({ ...outputs, format }))
|
||||
}
|
||||
return outputs
|
||||
}
|
||||
|
||||
export function electronMainVitePlugin(options?: ElectronPluginOptions): Plugin[] {
|
||||
return [
|
||||
{
|
||||
name: 'vite:electron-main-preset-config',
|
||||
apply: 'build',
|
||||
enforce: 'pre',
|
||||
config(config): void {
|
||||
@ -53,36 +66,45 @@ export function electronMainConfigPresetPlugin(options?: ElectronPluginOptions):
|
||||
const format = pkg.type && pkg.type === 'module' && supportESM() ? 'es' : 'cjs'
|
||||
|
||||
const defaultConfig = {
|
||||
resolve: {
|
||||
browserField: false,
|
||||
mainFields: ['module', 'jsnext:main', 'jsnext'],
|
||||
conditions: ['node']
|
||||
},
|
||||
build: {
|
||||
outDir: path.resolve(root, 'out', 'main'),
|
||||
target: nodeTarget,
|
||||
assetsDir: 'chunks',
|
||||
rolldownOptions: {
|
||||
rollupOptions: {
|
||||
external: ['electron', /^electron\/.+/, ...builtinModules.flatMap(m => [m, `node:${m}`])],
|
||||
output: {}
|
||||
},
|
||||
reportCompressedSize: false,
|
||||
minify: false
|
||||
}
|
||||
} satisfies UserConfig
|
||||
}
|
||||
|
||||
const build = config.build || {}
|
||||
const rolldownOptions = build.rolldownOptions || {}
|
||||
if (!rolldownOptions.input) {
|
||||
const rollupOptions = build.rollupOptions || {}
|
||||
if (!rollupOptions.input) {
|
||||
const libOptions = build.lib
|
||||
const outputOptions = rolldownOptions.output
|
||||
const outputOptions = rollupOptions.output
|
||||
defaultConfig.build['lib'] = {
|
||||
entry: findLibEntry(root, 'main'),
|
||||
formats:
|
||||
libOptions && libOptions.formats && libOptions.formats.length > 0
|
||||
? []
|
||||
: [outputOptions && !Array.isArray(outputOptions) && outputOptions.format ? outputOptions.format : format]
|
||||
: [
|
||||
outputOptions && !Array.isArray(outputOptions) && outputOptions.format
|
||||
? outputOptions.format
|
||||
: format
|
||||
]
|
||||
}
|
||||
} else {
|
||||
defaultConfig.build.rolldownOptions.output['format'] = format
|
||||
defaultConfig.build.rollupOptions.output['format'] = format
|
||||
}
|
||||
|
||||
defaultConfig.build.rolldownOptions.output['assetFileNames'] = path.posix.join(
|
||||
defaultConfig.build.rollupOptions.output['assetFileNames'] = path.posix.join(
|
||||
build.assetsDir || defaultConfig.build.assetsDir,
|
||||
'[name]-[hash].[ext]'
|
||||
)
|
||||
@ -90,6 +112,8 @@ export function electronMainConfigPresetPlugin(options?: ElectronPluginOptions):
|
||||
const buildConfig = mergeConfig(defaultConfig.build, build)
|
||||
config.build = buildConfig
|
||||
|
||||
config.resolve = mergeConfig(defaultConfig.resolve, config.resolve || {})
|
||||
|
||||
config.define = config.define || {}
|
||||
config.define = { ...processEnvDefine(), ...config.define }
|
||||
|
||||
@ -104,15 +128,10 @@ export function electronMainConfigPresetPlugin(options?: ElectronPluginOptions):
|
||||
config.build.ssr = true
|
||||
config.build.ssrEmitAssets = true
|
||||
config.ssr = { ...config.ssr, ...{ noExternal: true } }
|
||||
|
||||
config.build.rollupOptions = config.build.rolldownOptions
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function electronMainConfigValidatorPlugin(): Plugin {
|
||||
return {
|
||||
name: 'vite:electron-main-config-validator',
|
||||
},
|
||||
{
|
||||
name: 'vite:electron-main-resolved-config',
|
||||
apply: 'build',
|
||||
enforce: 'post',
|
||||
configResolved(config): void {
|
||||
@ -127,25 +146,25 @@ export function electronMainConfigValidatorPlugin(): Plugin {
|
||||
}
|
||||
|
||||
const libOptions = build.lib
|
||||
const rolldownOptions = build.rolldownOptions
|
||||
const rollupOptions = build.rollupOptions
|
||||
|
||||
if (!(libOptions && libOptions.entry) && !rolldownOptions?.input) {
|
||||
if (!(libOptions && libOptions.entry) && !rollupOptions?.input) {
|
||||
throw new Error(
|
||||
'An entry point is required in the electron vite main config, ' +
|
||||
'which can be specified using build.lib.entry, build.rollupOptions.input, ' +
|
||||
'or build.rolldownOptions.input.'
|
||||
'which can be specified using "build.lib.entry" or "build.rollupOptions.input".'
|
||||
)
|
||||
}
|
||||
|
||||
const outputs = resolveBuildOutputs(rolldownOptions.output, libOptions)
|
||||
const resolvedOutputs = resolveBuildOutputs(rollupOptions.output, libOptions)
|
||||
|
||||
if (outputs.length > 0) {
|
||||
if (resolvedOutputs) {
|
||||
const outputs = Array.isArray(resolvedOutputs) ? resolvedOutputs : [resolvedOutputs]
|
||||
if (outputs.length > 1) {
|
||||
throw new Error('The electron vite main config does not support multiple outputs.')
|
||||
} else {
|
||||
const output = outputs[0]
|
||||
if (['es', 'cjs'].includes(output.format || '')) {
|
||||
if (output.format === 'es' && !supportESM()) {
|
||||
const outpout = outputs[0]
|
||||
if (['es', 'cjs'].includes(outpout.format || '')) {
|
||||
if (outpout.format === 'es' && !supportESM()) {
|
||||
throw new Error(
|
||||
'The electron vite main config output format does not support "es", ' +
|
||||
'you can upgrade electron to the latest version or switch to "cjs" format.'
|
||||
@ -160,11 +179,13 @@ export function electronMainConfigValidatorPlugin(): Plugin {
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
export function electronPreloadConfigPresetPlugin(options?: ElectronPluginOptions): Plugin {
|
||||
return {
|
||||
name: 'vite:electron-preload-config-preset',
|
||||
export function electronPreloadVitePlugin(options?: ElectronPluginOptions): Plugin[] {
|
||||
return [
|
||||
{
|
||||
name: 'vite:electron-preload-preset-config',
|
||||
apply: 'build',
|
||||
enforce: 'pre',
|
||||
config(config): void {
|
||||
@ -187,32 +208,36 @@ export function electronPreloadConfigPresetPlugin(options?: ElectronPluginOption
|
||||
outDir: path.resolve(root, 'out', 'preload'),
|
||||
target: nodeTarget,
|
||||
assetsDir: 'chunks',
|
||||
rolldownOptions: {
|
||||
rollupOptions: {
|
||||
external: ['electron', /^electron\/.+/, ...builtinModules.flatMap(m => [m, `node:${m}`])],
|
||||
output: {}
|
||||
},
|
||||
reportCompressedSize: false,
|
||||
minify: false
|
||||
}
|
||||
} satisfies UserConfig
|
||||
}
|
||||
|
||||
const build = config.build || {}
|
||||
const rolldownOptions = build.rolldownOptions || {}
|
||||
if (!rolldownOptions.input) {
|
||||
const rollupOptions = build.rollupOptions || {}
|
||||
if (!rollupOptions.input) {
|
||||
const libOptions = build.lib
|
||||
const outputOptions = rolldownOptions.output
|
||||
const outputOptions = rollupOptions.output
|
||||
defaultConfig.build['lib'] = {
|
||||
entry: findLibEntry(root, 'preload'),
|
||||
formats:
|
||||
libOptions && libOptions.formats && libOptions.formats.length > 0
|
||||
? []
|
||||
: [outputOptions && !Array.isArray(outputOptions) && outputOptions.format ? outputOptions.format : format]
|
||||
: [
|
||||
outputOptions && !Array.isArray(outputOptions) && outputOptions.format
|
||||
? outputOptions.format
|
||||
: format
|
||||
]
|
||||
}
|
||||
} else {
|
||||
defaultConfig.build.rolldownOptions.output['format'] = format
|
||||
defaultConfig.build.rollupOptions.output['format'] = format
|
||||
}
|
||||
|
||||
defaultConfig.build.rolldownOptions.output['assetFileNames'] = path.posix.join(
|
||||
defaultConfig.build.rollupOptions.output['assetFileNames'] = path.posix.join(
|
||||
build.assetsDir || defaultConfig.build.assetsDir,
|
||||
'[name]-[hash].[ext]'
|
||||
)
|
||||
@ -220,21 +245,23 @@ export function electronPreloadConfigPresetPlugin(options?: ElectronPluginOption
|
||||
const buildConfig = mergeConfig(defaultConfig.build, build)
|
||||
config.build = buildConfig
|
||||
|
||||
const outputs = resolveBuildOutputs(config.build.rolldownOptions!.output, config.build.lib)
|
||||
const resolvedOutputs = resolveBuildOutputs(config.build.rollupOptions!.output, config.build.lib || false)
|
||||
|
||||
if (outputs.some(({ format }) => format === 'es')) {
|
||||
if (Array.isArray(config.build.rolldownOptions!.output)) {
|
||||
config.build.rolldownOptions!.output.forEach(output => {
|
||||
if (resolvedOutputs) {
|
||||
const outputs = Array.isArray(resolvedOutputs) ? resolvedOutputs : [resolvedOutputs]
|
||||
|
||||
if (outputs.find(({ format }) => format === 'es')) {
|
||||
if (Array.isArray(config.build.rollupOptions!.output)) {
|
||||
config.build.rollupOptions!.output.forEach(output => {
|
||||
if (output.format === 'es') {
|
||||
output['entryFileNames'] = '[name].mjs'
|
||||
output['chunkFileNames'] = '[name]-[hash].mjs'
|
||||
}
|
||||
})
|
||||
} else {
|
||||
config.build.rolldownOptions!.output!['entryFileNames'] = '[name].mjs'
|
||||
config.build.rolldownOptions!.output!['chunkFileNames'] = config.build.lib
|
||||
? '[name]-[hash].mjs'
|
||||
: path.posix.join(build.assetsDir || defaultConfig.build.assetsDir, '[name]-[hash].mjs')
|
||||
config.build.rollupOptions!.output!['entryFileNames'] = '[name].mjs'
|
||||
config.build.rollupOptions!.output!['chunkFileNames'] = '[name]-[hash].mjs'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -253,15 +280,10 @@ export function electronPreloadConfigPresetPlugin(options?: ElectronPluginOption
|
||||
config.build.ssrEmitAssets = true
|
||||
config.ssr = mergeConfig(defaultConfig.ssr, config.ssr || {})
|
||||
config.ssr.noExternal = true
|
||||
|
||||
config.build.rollupOptions = config.build.rolldownOptions
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function electronPreloadConfigValidatorPlugin(): Plugin {
|
||||
return {
|
||||
name: 'vite:electron-preload-config-validator',
|
||||
},
|
||||
{
|
||||
name: 'vite:electron-preload-resolved-config',
|
||||
apply: 'build',
|
||||
enforce: 'post',
|
||||
configResolved(config): void {
|
||||
@ -276,25 +298,25 @@ export function electronPreloadConfigValidatorPlugin(): Plugin {
|
||||
}
|
||||
|
||||
const libOptions = build.lib
|
||||
const rolldownOptions = build.rolldownOptions
|
||||
const rollupOptions = build.rollupOptions
|
||||
|
||||
if (!(libOptions && libOptions.entry) && !rolldownOptions?.input) {
|
||||
if (!(libOptions && libOptions.entry) && !rollupOptions?.input) {
|
||||
throw new Error(
|
||||
'An entry point is required in the electron vite preload config, ' +
|
||||
'which can be specified using build.lib.entry, build.rollupOptions.input, ' +
|
||||
' or build.rolldownOptions.input.'
|
||||
'which can be specified using "build.lib.entry" or "build.rollupOptions.input".'
|
||||
)
|
||||
}
|
||||
|
||||
const outputs = resolveBuildOutputs(rolldownOptions.output, libOptions)
|
||||
const resolvedOutputs = resolveBuildOutputs(rollupOptions.output, libOptions)
|
||||
|
||||
if (outputs.length > 0) {
|
||||
if (resolvedOutputs) {
|
||||
const outputs = Array.isArray(resolvedOutputs) ? resolvedOutputs : [resolvedOutputs]
|
||||
if (outputs.length > 1) {
|
||||
throw new Error('The electron vite preload config does not support multiple outputs.')
|
||||
} else {
|
||||
const output = outputs[0]
|
||||
if (['es', 'cjs'].includes(output.format || '')) {
|
||||
if (output.format === 'es' && !supportESM()) {
|
||||
const outpout = outputs[0]
|
||||
if (['es', 'cjs'].includes(outpout.format || '')) {
|
||||
if (outpout.format === 'es' && !supportESM()) {
|
||||
throw new Error(
|
||||
'The electron vite preload config output format does not support "es", ' +
|
||||
'you can upgrade electron to the latest version or switch to "cjs" format.'
|
||||
@ -309,11 +331,13 @@ export function electronPreloadConfigValidatorPlugin(): Plugin {
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
export function electronRendererConfigPresetPlugin(options?: ElectronPluginOptions): Plugin {
|
||||
return {
|
||||
name: 'vite:electron-renderer-config-preset',
|
||||
export function electronRendererVitePlugin(options?: ElectronPluginOptions): Plugin[] {
|
||||
return [
|
||||
{
|
||||
name: 'vite:electron-renderer-preset-config',
|
||||
enforce: 'pre',
|
||||
config(config): void {
|
||||
const root = options?.root || process.cwd()
|
||||
@ -341,14 +365,14 @@ export function electronRendererConfigPresetPlugin(options?: ElectronPluginOptio
|
||||
outDir: path.resolve(root, 'out', 'renderer'),
|
||||
target: chromeTarget,
|
||||
modulePreload: { polyfill: false },
|
||||
rolldownOptions: {
|
||||
rollupOptions: {
|
||||
input: findInput(root)
|
||||
},
|
||||
reportCompressedSize: false,
|
||||
minify: false,
|
||||
emptyOutDir: emptyOutDir()
|
||||
}
|
||||
} satisfies UserConfig
|
||||
}
|
||||
|
||||
if (config.build?.outDir) {
|
||||
config.build.outDir = path.resolve(root, config.build.outDir)
|
||||
@ -360,15 +384,10 @@ export function electronRendererConfigPresetPlugin(options?: ElectronPluginOptio
|
||||
config.envDir = config.envDir || path.resolve(root)
|
||||
|
||||
config.envPrefix = config.envPrefix || ['RENDERER_VITE_', 'VITE_']
|
||||
|
||||
config.build.rollupOptions = config.build.rolldownOptions
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function electronRendererConfigValidatorPlugin(): Plugin {
|
||||
return {
|
||||
name: 'vite:electron-renderer-config-validator',
|
||||
},
|
||||
{
|
||||
name: 'vite:electron-renderer-resolved-config',
|
||||
enforce: 'post',
|
||||
configResolved(config): void {
|
||||
if (config.base !== './' && config.base !== '/') {
|
||||
@ -387,13 +406,12 @@ export function electronRendererConfigValidatorPlugin(): Plugin {
|
||||
}
|
||||
}
|
||||
|
||||
const rolldownOptions = build.rolldownOptions
|
||||
if (!rolldownOptions.input) {
|
||||
const rollupOptions = build.rollupOptions
|
||||
if (!rollupOptions.input) {
|
||||
config.logger.warn(colors.yellow(`index.html file is not found in ${colors.dim('/src/renderer')} directory.`))
|
||||
throw new Error(
|
||||
'build.rollupOptions.input or build.rolldownOptions.input option is required in the electron vite renderer config.'
|
||||
)
|
||||
throw new Error('build.rollupOptions.input option is required in the electron vite renderer config.')
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
79
src/plugins/esm.ts
Normal file
79
src/plugins/esm.ts
Normal file
@ -0,0 +1,79 @@
|
||||
/*
|
||||
* The core of this plugin was conceived by pi0 and is taken from the following repository:
|
||||
* https://github.com/unjs/unbuild/blob/main/src/builder/plugins/cjs.ts
|
||||
* license: https://github.com/unjs/unbuild/blob/main/LICENSE
|
||||
*/
|
||||
|
||||
import MagicString from 'magic-string'
|
||||
import type { SourceMapInput } from 'rollup'
|
||||
import type { Plugin } from 'vite'
|
||||
|
||||
import { getElectronMajorVersion } from '../electron'
|
||||
|
||||
const CJSyntaxRe = /__filename|__dirname|require\(|require\.resolve\(/
|
||||
|
||||
const CJSShim_normal = `
|
||||
// -- CommonJS Shims --
|
||||
import __cjs_url__ from 'node:url';
|
||||
import __cjs_path__ from 'node:path';
|
||||
import __cjs_mod__ from 'node:module';
|
||||
const __filename = __cjs_url__.fileURLToPath(import.meta.url);
|
||||
const __dirname = __cjs_path__.dirname(__filename);
|
||||
const require = __cjs_mod__.createRequire(import.meta.url);
|
||||
`
|
||||
|
||||
const CJSShim_node_20_11 = `
|
||||
// -- CommonJS Shims --
|
||||
import __cjs_mod__ from 'node:module';
|
||||
const __filename = import.meta.filename;
|
||||
const __dirname = import.meta.dirname;
|
||||
const require = __cjs_mod__.createRequire(import.meta.url);
|
||||
`
|
||||
|
||||
const ESMStaticImportRe =
|
||||
/(?<=\s|^|;)import\s*([\s"']*(?<imports>[\p{L}\p{M}\w\t\n\r $*,/{}@.]+)from\s*)?["']\s*(?<specifier>(?<="\s*)[^"]*[^\s"](?=\s*")|(?<='\s*)[^']*[^\s'](?=\s*'))\s*["'][\s;]*/gmu
|
||||
|
||||
interface StaticImport {
|
||||
end: number
|
||||
}
|
||||
|
||||
function findStaticImports(code: string): StaticImport[] {
|
||||
const matches: StaticImport[] = []
|
||||
for (const match of code.matchAll(ESMStaticImportRe)) {
|
||||
matches.push({ end: (match.index || 0) + match[0].length })
|
||||
}
|
||||
return matches
|
||||
}
|
||||
|
||||
export default function esmShimPlugin(): Plugin {
|
||||
let sourcemap: boolean | 'inline' | 'hidden' = false
|
||||
|
||||
const CJSShim = getElectronMajorVersion() >= 30 ? CJSShim_node_20_11 : CJSShim_normal
|
||||
|
||||
return {
|
||||
name: 'vite:esm-shim',
|
||||
apply: 'build',
|
||||
enforce: 'post',
|
||||
configResolved(config): void {
|
||||
sourcemap = config.build.sourcemap
|
||||
},
|
||||
renderChunk(code, _chunk, options): { code: string; map?: SourceMapInput } | null {
|
||||
if (options.format === 'es') {
|
||||
if (code.includes(CJSShim) || !CJSyntaxRe.test(code)) {
|
||||
return null
|
||||
}
|
||||
|
||||
const lastESMImport = findStaticImports(code).pop()
|
||||
const indexToAppend = lastESMImport ? lastESMImport.end : 0
|
||||
const s = new MagicString(code)
|
||||
s.appendRight(indexToAppend, CJSShim)
|
||||
return {
|
||||
code: s.toString(),
|
||||
map: sourcemap ? s.generateMap({ hires: 'boundary' }) : null
|
||||
}
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,55 +0,0 @@
|
||||
import MagicString from 'magic-string'
|
||||
import type { Plugin } from 'vite'
|
||||
|
||||
import { supportImportMetaPaths } from '../electron'
|
||||
|
||||
const CJSyntaxRe = /__filename|__dirname|require\(|require\.resolve\(/
|
||||
|
||||
const CJSShim_normal = `
|
||||
// -- CommonJS Shims --
|
||||
import __shims_url__ from 'node:url';
|
||||
import __shims_path__ from 'node:path';
|
||||
import __shims_module__ from 'node:module';
|
||||
const __filename = __shims_url__.fileURLToPath(import.meta.url);
|
||||
const __dirname = __shims_path__.dirname(__filename);
|
||||
const require = __shims_module__.createRequire(import.meta.url);
|
||||
`
|
||||
|
||||
const CJSShim_node_20_11 = `
|
||||
// -- CommonJS Shims --
|
||||
import __shims_module__ from 'node:module';
|
||||
const __filename = import.meta.filename;
|
||||
const __dirname = import.meta.dirname;
|
||||
const require = __shims_module__.createRequire(import.meta.url);
|
||||
`
|
||||
|
||||
export default function esmShimPlugin(): Plugin {
|
||||
const CJSShim = supportImportMetaPaths() ? CJSShim_node_20_11 : CJSShim_normal
|
||||
|
||||
return {
|
||||
name: 'vite:esm-shim',
|
||||
apply: 'build',
|
||||
enforce: 'post',
|
||||
renderChunk(code, _chunk, { format, sourcemap }) {
|
||||
if (format === 'es') {
|
||||
// Rolldown may remove unused shim bindings after this hook; referenced bindings remain available.
|
||||
if (code.includes(CJSShim) || !CJSyntaxRe.test(code)) {
|
||||
return null
|
||||
}
|
||||
|
||||
const lastESMImport = this.parse(code)
|
||||
.body.filter(node => node.type === 'ImportDeclaration')
|
||||
.pop()
|
||||
const indexToAppend = lastESMImport ? lastESMImport.end : 0
|
||||
const s = new MagicString(code)
|
||||
s.appendRight(indexToAppend, CJSShim)
|
||||
return {
|
||||
code: s.toString(),
|
||||
map: sourcemap ? s.generateMap({ hires: 'boundary' }) : null
|
||||
}
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -7,9 +7,7 @@ export interface ExternalOptions {
|
||||
}
|
||||
|
||||
/**
|
||||
* Automatically externalize dependencies.
|
||||
*
|
||||
* @deprecated use `build.externalizeDeps` config option instead
|
||||
* Automatically externalize dependencies
|
||||
*/
|
||||
export function externalizeDepsPlugin(options: ExternalOptions = {}): Plugin | null {
|
||||
const { exclude = [], include = [] } = options
|
||||
@ -33,15 +31,13 @@ export function externalizeDepsPlugin(options: ExternalOptions = {}): Plugin | n
|
||||
config(config): void {
|
||||
const defaultConfig = {
|
||||
build: {
|
||||
rolldownOptions: {
|
||||
rollupOptions: {
|
||||
external: deps.length > 0 ? [...deps, new RegExp(`^(${deps.join('|')})/.+`)] : []
|
||||
}
|
||||
}
|
||||
}
|
||||
const buildConfig = mergeConfig(defaultConfig.build, config.build || {})
|
||||
config.build = buildConfig
|
||||
|
||||
config.build.rollupOptions = config.build.rolldownOptions
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,19 +1,6 @@
|
||||
/* eslint-disable @typescript-eslint/no-explicit-any */
|
||||
import { type Plugin, version } from 'vite'
|
||||
import type { Plugin } from 'vite'
|
||||
|
||||
/**
|
||||
* @deprecated Vite 8 (Rolldown) now provides native support for these
|
||||
* `import.meta` properties. These properties are polyfilled when the output
|
||||
* format is CJS.
|
||||
*
|
||||
* @see https://rolldown.rs/in-depth/non-esm-output-formats#well-known-import-meta-properties
|
||||
*/
|
||||
export default function importMetaPlugin(): Plugin | null {
|
||||
const currentVersion = version.split('.')
|
||||
const major = parseInt(currentVersion[0], 10)
|
||||
if (major >= 8) {
|
||||
return null
|
||||
}
|
||||
export default function importMetaPlugin(): Plugin {
|
||||
return {
|
||||
name: 'vite:import-meta',
|
||||
apply: 'build',
|
||||
@ -30,5 +17,5 @@ export default function importMetaPlugin(): Plugin | null {
|
||||
}
|
||||
return null
|
||||
}
|
||||
} as any
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,199 +0,0 @@
|
||||
/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-function-type */
|
||||
import path from 'node:path'
|
||||
import { type InlineConfig, type Plugin, type LogLevel, type Rolldown, build as viteBuild, mergeConfig } from 'vite'
|
||||
import colors from 'picocolors'
|
||||
import { cleanUrl } from '../utils'
|
||||
import type { ConfigFactory, PreloadViteConfig, RendererViteConfig } from '../config'
|
||||
|
||||
const VIRTUAL_ENTRY_ID = '\0virtual:isolate-entries'
|
||||
|
||||
const LogLevels: Record<LogLevel, number> = {
|
||||
silent: 0,
|
||||
error: 1,
|
||||
warn: 2,
|
||||
info: 3
|
||||
}
|
||||
|
||||
export default function isolateEntriesPlugin(factory: ConfigFactory<PreloadViteConfig | RendererViteConfig>): Plugin {
|
||||
let entries: string[] | { [x: string]: string }[]
|
||||
|
||||
let transformedCount = 0
|
||||
|
||||
const assetCache = new Set<string>()
|
||||
|
||||
return {
|
||||
name: 'vite:isolate-entries',
|
||||
apply: 'build',
|
||||
|
||||
options(opts): Rolldown.InputOptions | void {
|
||||
const { input } = opts
|
||||
if (input && typeof input === 'object') {
|
||||
if ((Array.isArray(input) && input.length > 0) || Object.keys(input).length > 1) {
|
||||
opts.input = VIRTUAL_ENTRY_ID
|
||||
entries = Array.isArray(input) ? input : Object.entries(input).map(([key, value]) => ({ [key]: value }))
|
||||
return opts
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
buildStart(): void {
|
||||
transformedCount = 0
|
||||
assetCache.clear()
|
||||
},
|
||||
|
||||
resolveId(id): string | null {
|
||||
if (id === VIRTUAL_ENTRY_ID) {
|
||||
return id
|
||||
}
|
||||
return null
|
||||
},
|
||||
|
||||
async load(id): Promise<string | void> {
|
||||
if (id === VIRTUAL_ENTRY_ID) {
|
||||
const userConfig = await factory.build(true)
|
||||
const shouldLog = LogLevels[userConfig.logLevel || 'info'] >= LogLevels.info
|
||||
|
||||
const watchFiles = new Set<string>()
|
||||
|
||||
for (const entry of entries) {
|
||||
const re = await bundleEntryFile(entry, userConfig, shouldLog, transformedCount)
|
||||
|
||||
const outputChunks = re.bundles.output
|
||||
for (const chunk of outputChunks) {
|
||||
if (assetCache.has(chunk.fileName)) {
|
||||
continue
|
||||
}
|
||||
this.emitFile({
|
||||
type: 'asset',
|
||||
fileName: chunk.fileName,
|
||||
source: chunk.type === 'chunk' ? chunk.code : chunk.source
|
||||
})
|
||||
assetCache.add(chunk.fileName)
|
||||
}
|
||||
|
||||
if (this.meta.watchMode) {
|
||||
const moduleIds = new Set<string>()
|
||||
for (const chunk of re.bundles.output) {
|
||||
if (chunk.type === 'chunk') {
|
||||
for (const id of chunk.moduleIds) {
|
||||
if (!id.startsWith('\0')) {
|
||||
moduleIds.add(cleanUrl(id))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const id of moduleIds) {
|
||||
this.addWatchFile(id)
|
||||
}
|
||||
}
|
||||
|
||||
transformedCount += re.transformedCount
|
||||
}
|
||||
|
||||
for (const id of watchFiles) {
|
||||
this.addWatchFile(id)
|
||||
}
|
||||
|
||||
return `
|
||||
// This is the virtual entry file
|
||||
console.log(1)`
|
||||
}
|
||||
},
|
||||
|
||||
renderStart(): void {
|
||||
clearLine(-1)
|
||||
this.environment.logger.info(`${colors.green(`✓`)} ${transformedCount} modules transformed.`)
|
||||
},
|
||||
|
||||
generateBundle(_, bundle): void {
|
||||
for (const chunkName in bundle) {
|
||||
if (chunkName.includes('virtual_isolate-entries')) {
|
||||
delete bundle[chunkName]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async function bundleEntryFile(
|
||||
input: string | Record<string, string>,
|
||||
config: InlineConfig,
|
||||
shouldLog: boolean,
|
||||
preTransformedCount: number
|
||||
): Promise<{ bundles: Rolldown.RolldownOutput; transformedCount: number }> {
|
||||
const transformReporter = transformReporterPlugin(preTransformedCount, shouldLog)
|
||||
|
||||
const viteConfig = mergeConfig(config, {
|
||||
build: {
|
||||
write: false,
|
||||
watch: false
|
||||
},
|
||||
plugins: [transformReporter],
|
||||
logLevel: 'warn',
|
||||
configFile: false
|
||||
}) as InlineConfig
|
||||
|
||||
// rewrite the input instead of merging
|
||||
viteConfig.build!.rolldownOptions!.input = input
|
||||
|
||||
const bundles = (await viteBuild(viteConfig)) as Rolldown.RolldownOutput
|
||||
|
||||
return {
|
||||
bundles: bundles,
|
||||
transformedCount: transformReporter?.api?.getTransformedCount() || 0
|
||||
}
|
||||
}
|
||||
|
||||
function transformReporterPlugin(
|
||||
preTransformedCount = 0,
|
||||
shouldLog = true
|
||||
): Plugin<{ getTransformedCount: () => number }> {
|
||||
let transformedCount = 0
|
||||
const log = throttle((id, root) => {
|
||||
writeLine(`transforming (${preTransformedCount + transformedCount}) ${colors.dim(path.relative(root, id))}`)
|
||||
})
|
||||
return {
|
||||
name: 'vite:transform-reporter',
|
||||
transform(_, id) {
|
||||
transformedCount++
|
||||
if (!shouldLog) return
|
||||
if (id.includes('?')) return
|
||||
log(id, this.environment.config.root)
|
||||
},
|
||||
api: {
|
||||
getTransformedCount() {
|
||||
return transformedCount
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function writeLine(output: string): void {
|
||||
if (!process.stdout.isTTY || process.env.CI) return
|
||||
clearLine()
|
||||
if (output.length < process.stdout.columns) {
|
||||
process.stdout.write(output)
|
||||
} else {
|
||||
process.stdout.write(output.substring(0, process.stdout.columns - 1))
|
||||
}
|
||||
}
|
||||
|
||||
function clearLine(move: number = 0): void {
|
||||
if (!process.stdout.isTTY || process.env.CI) return
|
||||
if (move < 0) {
|
||||
process.stdout.moveCursor(0, move)
|
||||
}
|
||||
process.stdout.clearLine(0)
|
||||
process.stdout.cursorTo(0)
|
||||
}
|
||||
|
||||
function throttle(fn: Function) {
|
||||
let timerHandle: NodeJS.Timeout | null = null
|
||||
return (...args: any[]) => {
|
||||
if (timerHandle) return
|
||||
fn(...args)
|
||||
timerHandle = setTimeout(() => {
|
||||
timerHandle = null
|
||||
}, 100)
|
||||
}
|
||||
}
|
||||
@ -1,75 +1,49 @@
|
||||
import { type Plugin, type InlineConfig, type Rolldown, build as viteBuild, mergeConfig } from 'vite'
|
||||
import type { Plugin } from 'vite'
|
||||
import type { SourceMapInput } from 'rollup'
|
||||
import MagicString from 'magic-string'
|
||||
import { cleanUrl, toRelativePath } from '../utils'
|
||||
import { supportImportMetaPaths } from '../electron'
|
||||
import type { ConfigFactory, MainViteConfig } from '../config'
|
||||
import { cleanUrl, parseRequest, toRelativePath } from '../utils'
|
||||
|
||||
const modulePathRE = /__VITE_MODULE_PATH__([\w$]+)__/g
|
||||
|
||||
/**
|
||||
* Resolve `?modulePath` import and return the module bundle path.
|
||||
*/
|
||||
export default function modulePathPlugin(factory: ConfigFactory<MainViteConfig>): Plugin {
|
||||
const isImportMetaPathSupported = supportImportMetaPaths()
|
||||
const assetCache = new Set<string>()
|
||||
export default function modulePathPlugin(): Plugin {
|
||||
let sourcemap: boolean | 'inline' | 'hidden' = false
|
||||
return {
|
||||
name: 'vite:module-path',
|
||||
apply: 'build',
|
||||
enforce: 'pre',
|
||||
buildStart(): void {
|
||||
assetCache.clear()
|
||||
configResolved(config): void {
|
||||
sourcemap = config.build.sourcemap
|
||||
},
|
||||
async load(id): Promise<string | void> {
|
||||
if (id.endsWith('?modulePath')) {
|
||||
// id resolved by Vite resolve plugin
|
||||
const config = await factory.build(true)
|
||||
const bundles = await bundleEntryFile(cleanUrl(id), config)
|
||||
const [outputChunk, ...outputChunks] = bundles.output
|
||||
resolveId(id, importer): string | void {
|
||||
const query = parseRequest(id)
|
||||
if (query && typeof query.modulePath === 'string') {
|
||||
return id + `&importer=${importer}`
|
||||
}
|
||||
},
|
||||
load(id): string | void {
|
||||
const query = parseRequest(id)
|
||||
if (query && typeof query.modulePath === 'string' && typeof query.importer === 'string') {
|
||||
const cleanPath = cleanUrl(id)
|
||||
const hash = this.emitFile({
|
||||
type: 'asset',
|
||||
fileName: outputChunk.fileName,
|
||||
source: outputChunk.code
|
||||
type: 'chunk',
|
||||
id: cleanPath,
|
||||
importer: query.importer
|
||||
})
|
||||
for (const chunk of outputChunks) {
|
||||
if (assetCache.has(chunk.fileName)) {
|
||||
continue
|
||||
}
|
||||
this.emitFile({
|
||||
type: 'asset',
|
||||
fileName: chunk.fileName,
|
||||
source: chunk.type === 'chunk' ? chunk.code : chunk.source
|
||||
})
|
||||
assetCache.add(chunk.fileName)
|
||||
}
|
||||
if (this.meta.watchMode) {
|
||||
const moduleIds = new Set<string>()
|
||||
for (const chunk of bundles.output) {
|
||||
if (chunk.type === 'chunk') {
|
||||
for (const id of chunk.moduleIds) {
|
||||
if (!id.startsWith('\0')) {
|
||||
moduleIds.add(cleanUrl(id))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const id of moduleIds) {
|
||||
this.addWatchFile(id)
|
||||
}
|
||||
}
|
||||
const refId = `__VITE_MODULE_PATH__${hash}__`
|
||||
const dirnameExpr = isImportMetaPathSupported ? 'import.meta.dirname' : '__dirname'
|
||||
return `
|
||||
import { join } from 'path'
|
||||
export default join(${dirnameExpr}, ${refId})`
|
||||
export default join(__dirname, ${refId})`
|
||||
}
|
||||
},
|
||||
renderChunk(code, chunk, { sourcemap }): { code: string; map: Rolldown.SourceMapInput } | null {
|
||||
renderChunk(code, chunk): { code: string; map: SourceMapInput } | null {
|
||||
if (code.match(modulePathRE)) {
|
||||
let match: RegExpExecArray | null
|
||||
let s: MagicString | undefined
|
||||
const s = new MagicString(code)
|
||||
|
||||
modulePathRE.lastIndex = 0
|
||||
while ((match = modulePathRE.exec(code))) {
|
||||
s ||= new MagicString(code)
|
||||
const [full, hash] = match
|
||||
const filename = this.getFileName(hash)
|
||||
const outputFilepath = toRelativePath(filename, chunk.fileName)
|
||||
@ -79,7 +53,6 @@ export default function modulePathPlugin(factory: ConfigFactory<MainViteConfig>)
|
||||
})
|
||||
}
|
||||
|
||||
if (s) {
|
||||
return {
|
||||
code: s.toString(),
|
||||
map: sourcemap ? s.generateMap({ hires: 'boundary' }) : null
|
||||
@ -90,37 +63,3 @@ export default function modulePathPlugin(factory: ConfigFactory<MainViteConfig>)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async function bundleEntryFile(input: string, config: InlineConfig): Promise<Rolldown.RolldownOutput> {
|
||||
const viteConfig = mergeConfig(config, {
|
||||
build: {
|
||||
write: false,
|
||||
watch: false
|
||||
},
|
||||
plugins: [
|
||||
{
|
||||
name: 'vite:entry-file-name',
|
||||
outputOptions(output): Rolldown.OutputOptions {
|
||||
// Prevent output conflicts
|
||||
output.hashCharacters = 'hex'
|
||||
// Assign chunkFileNames to entryFileNames to treat sub-entries as internal chunks
|
||||
output.entryFileNames = output.chunkFileNames
|
||||
return output
|
||||
}
|
||||
}
|
||||
] as Plugin[],
|
||||
logLevel: 'warn',
|
||||
configFile: false
|
||||
}) as InlineConfig
|
||||
|
||||
// rewrite the input instead of merging
|
||||
const buildOptions = viteConfig.build!
|
||||
buildOptions.rolldownOptions = {
|
||||
...buildOptions.rolldownOptions,
|
||||
input
|
||||
}
|
||||
|
||||
const bundles = await viteBuild(viteConfig)
|
||||
|
||||
return bundles as Rolldown.RolldownOutput
|
||||
}
|
||||
|
||||
@ -79,16 +79,12 @@ export type SwcOptions = {
|
||||
export function swcPlugin(options: SwcOptions = {}): Plugin {
|
||||
const filter = createFilter(options.include || /\.(m?ts|[jt]sx)$/, options.exclude || /\.js$/)
|
||||
let sourcemap: boolean | 'inline' = false
|
||||
let minify: boolean | 'esbuild' | 'oxc' | 'terser' = false
|
||||
let minify: boolean | 'esbuild' | 'terser' = false
|
||||
return {
|
||||
name: 'vite:swc',
|
||||
config(): UserConfig {
|
||||
// Vite 8 defaults to Oxc for transform; `esbuild: false` is ignored and
|
||||
// warns. SWC replaces both paths when this plugin is active.
|
||||
// See https://github.com/alex8088/electron-vite/issues/916
|
||||
return {
|
||||
esbuild: false,
|
||||
oxc: false
|
||||
esbuild: false
|
||||
}
|
||||
},
|
||||
async configResolved(resolvedConfig): Promise<void> {
|
||||
@ -105,7 +101,7 @@ export function swcPlugin(options: SwcOptions = {}): Plugin {
|
||||
}
|
||||
},
|
||||
async renderChunk(code, chunk): Promise<null | { code: string; map: SourceMap }> {
|
||||
if (!minify || minify === 'terser' || minify === 'oxc') {
|
||||
if (!minify || minify === 'terser') {
|
||||
return null
|
||||
}
|
||||
const result = await transformWithSWC(code, chunk.fileName, {
|
||||
|
||||
@ -1,47 +1,49 @@
|
||||
import type { Plugin } from 'vite'
|
||||
import type { SourceMapInput } from 'rollup'
|
||||
import MagicString from 'magic-string'
|
||||
import { cleanUrl, toRelativePath } from '../utils'
|
||||
import { cleanUrl, parseRequest, toRelativePath } from '../utils'
|
||||
|
||||
const nodeWorkerAssetUrlRE = /__VITE_NODE_WORKER_ASSET__([\w$]+)__/g
|
||||
const nodeWorkerRE = /\?nodeWorker(?:&|$)/
|
||||
const nodeWorkerImporterRE = /(?:\?)nodeWorker&importer=([^&]+)(?:&|$)/
|
||||
|
||||
/**
|
||||
* Resolve `?nodeWorker` import and automatically generate `Worker` wrapper.
|
||||
*/
|
||||
export default function workerPlugin(): Plugin {
|
||||
let sourcemap: boolean | 'inline' | 'hidden' = false
|
||||
return {
|
||||
name: 'vite:node-worker',
|
||||
apply: 'build',
|
||||
enforce: 'pre',
|
||||
configResolved(config): void {
|
||||
sourcemap = config.build.sourcemap
|
||||
},
|
||||
resolveId(id, importer): string | void {
|
||||
if (id.endsWith('?nodeWorker')) {
|
||||
const query = parseRequest(id)
|
||||
if (query && typeof query.nodeWorker === 'string') {
|
||||
return id + `&importer=${importer}`
|
||||
}
|
||||
},
|
||||
load(id): string | void {
|
||||
if (nodeWorkerRE.test(id)) {
|
||||
const match = nodeWorkerImporterRE.exec(id)
|
||||
if (match) {
|
||||
const query = parseRequest(id)
|
||||
if (query && typeof query.nodeWorker === 'string' && typeof query.importer === 'string') {
|
||||
const cleanPath = cleanUrl(id)
|
||||
const hash = this.emitFile({
|
||||
type: 'chunk',
|
||||
id: cleanUrl(id),
|
||||
importer: match[1]
|
||||
id: cleanPath,
|
||||
importer: query.importer
|
||||
})
|
||||
const assetRefId = `__VITE_NODE_WORKER_ASSET__${hash}__`
|
||||
return `
|
||||
import { Worker } from 'node:worker_threads';
|
||||
export default function (options) { return new Worker(new URL(${assetRefId}, import.meta.url), options); }`
|
||||
}
|
||||
}
|
||||
},
|
||||
renderChunk(code, chunk, { sourcemap }) {
|
||||
renderChunk(code, chunk): { code: string; map: SourceMapInput } | null {
|
||||
if (code.match(nodeWorkerAssetUrlRE)) {
|
||||
let match: RegExpExecArray | null
|
||||
let s: MagicString | undefined
|
||||
const s = new MagicString(code)
|
||||
|
||||
nodeWorkerAssetUrlRE.lastIndex = 0
|
||||
while ((match = nodeWorkerAssetUrlRE.exec(code))) {
|
||||
s ||= new MagicString(code)
|
||||
const [full, hash] = match
|
||||
const filename = this.getFileName(hash)
|
||||
const outputFilepath = toRelativePath(filename, chunk.fileName)
|
||||
@ -51,7 +53,6 @@ export default function workerPlugin(): Plugin {
|
||||
})
|
||||
}
|
||||
|
||||
if (s) {
|
||||
return {
|
||||
code: s.toString(),
|
||||
map: sourcemap ? s.generateMap({ hires: 'boundary' }) : null
|
||||
|
||||
@ -13,5 +13,5 @@ export async function preview(inlineConfig: InlineConfig = {}, options: { skipBu
|
||||
|
||||
startElectron(inlineConfig.root)
|
||||
|
||||
logger.info(colors.green(`\nstarting electron app...\n`))
|
||||
logger.info(colors.green(`\nstart electron app...\n`))
|
||||
}
|
||||
|
||||
@ -31,20 +31,22 @@ export async function createServer(
|
||||
const mainViteConfig = config.config?.main
|
||||
if (mainViteConfig && !options.rendererOnly) {
|
||||
const watchHook = (): void => {
|
||||
logger.info(colors.green(`\nelectron main process rebuilt successfully`))
|
||||
logger.info(colors.green(`\nrebuild the electron main process successfully`))
|
||||
|
||||
if (ps) {
|
||||
logger.info(colors.cyan(`\n waiting for electron to exit...`))
|
||||
|
||||
ps.removeAllListeners()
|
||||
ps.kill()
|
||||
ps = startElectron(inlineConfig.root)
|
||||
|
||||
logger.info(colors.green(`\nrestarting electron app...\n`))
|
||||
logger.info(colors.green(`\nrestart electron app...`))
|
||||
}
|
||||
}
|
||||
|
||||
await doBuild(mainViteConfig, watchHook, errorHook)
|
||||
|
||||
logger.info(colors.green(`\nelectron main process built successfully`))
|
||||
logger.info(colors.green(`\nbuild the electron main process successfully`))
|
||||
}
|
||||
|
||||
const preloadViteConfig = config.config?.preload
|
||||
@ -52,10 +54,10 @@ export async function createServer(
|
||||
logger.info(colors.gray(`\n-----\n`))
|
||||
|
||||
const watchHook = (): void => {
|
||||
logger.info(colors.green(`\nelectron preload scripts rebuilt successfully`))
|
||||
logger.info(colors.green(`\nrebuild the electron preload files successfully`))
|
||||
|
||||
if (server) {
|
||||
logger.info(colors.cyan(`\nreloading electron renderer...\n`))
|
||||
logger.info(colors.cyan(`\n trigger renderer reload`))
|
||||
|
||||
server.ws.send({ type: 'full-reload' })
|
||||
}
|
||||
@ -63,12 +65,14 @@ export async function createServer(
|
||||
|
||||
await doBuild(preloadViteConfig, watchHook, errorHook)
|
||||
|
||||
logger.info(colors.green(`\nelectron preload scripts built successfully`))
|
||||
logger.info(colors.green(`\nbuild the electron preload files successfully`))
|
||||
}
|
||||
|
||||
if (options.rendererOnly) {
|
||||
logger.warn(
|
||||
`\n${colors.yellow(colors.bold('(!)'))} ${colors.yellow('skipped building main process and preload scripts (using previous build)')}`
|
||||
`\n${colors.yellow(colors.bold('warn'))}:${colors.yellow(
|
||||
' you have skipped the main process and preload scripts building'
|
||||
)}`
|
||||
)
|
||||
}
|
||||
|
||||
@ -102,7 +106,7 @@ export async function createServer(
|
||||
|
||||
ps = startElectron(inlineConfig.root)
|
||||
|
||||
logger.info(colors.green(`\nstarting electron app...\n`))
|
||||
logger.info(colors.green(`\nstart electron app...\n`))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
123
src/utils.ts
123
src/utils.ts
@ -1,9 +1,9 @@
|
||||
/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-function-type */
|
||||
import { URL, URLSearchParams } from 'node:url'
|
||||
import path from 'node:path'
|
||||
import fs from 'node:fs'
|
||||
import { createHash } from 'node:crypto'
|
||||
import { createRequire } from 'node:module'
|
||||
import { type LibraryOptions, type Rolldown, loadEnv as viteLoadEnv } from 'vite'
|
||||
import { loadEnv as viteLoadEnv } from 'vite'
|
||||
|
||||
export function isObject(value: unknown): value is Record<string, unknown> {
|
||||
return Object.prototype.toString.call(value) === '[object Object]'
|
||||
@ -20,6 +20,14 @@ export const hashRE = /#.*$/s
|
||||
|
||||
export const cleanUrl = (url: string): string => url.replace(hashRE, '').replace(queryRE, '')
|
||||
|
||||
export function parseRequest(id: string): Record<string, string> | null {
|
||||
const { search } = new URL(id, 'file:')
|
||||
if (!search) {
|
||||
return null
|
||||
}
|
||||
return Object.fromEntries(new URLSearchParams(search))
|
||||
}
|
||||
|
||||
export function getHash(text: Buffer | string): string {
|
||||
return createHash('sha256')
|
||||
.update(text as unknown as Uint8Array)
|
||||
@ -32,23 +40,6 @@ export function toRelativePath(filename: string, importer: string): string {
|
||||
return relPath.startsWith('.') ? relPath : `./${relPath}`
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve configured build outputs into an array.
|
||||
*/
|
||||
export function resolveBuildOutputs(
|
||||
outputs: Rolldown.OutputOptions | Rolldown.OutputOptions[] | undefined,
|
||||
libOptions: LibraryOptions | false | undefined
|
||||
): Rolldown.OutputOptions[] {
|
||||
if (Array.isArray(outputs)) {
|
||||
return outputs
|
||||
}
|
||||
if (libOptions) {
|
||||
const libFormats = libOptions.formats || []
|
||||
return libFormats.map(format => ({ ...outputs, format }))
|
||||
}
|
||||
return outputs ? [outputs] : []
|
||||
}
|
||||
|
||||
/**
|
||||
* Load `.env` files within the `envDir` (default: `process.cwd()`) .
|
||||
* By default, only env variables prefixed with `VITE_`, `MAIN_VITE_`, `PRELOAD_VITE_` and
|
||||
@ -96,97 +87,3 @@ export function isFilePathESM(filePath: string): boolean {
|
||||
return pkg?.type === 'module'
|
||||
}
|
||||
}
|
||||
|
||||
type DeepWritable<T> =
|
||||
T extends ReadonlyArray<unknown>
|
||||
? { -readonly [P in keyof T]: DeepWritable<T[P]> }
|
||||
: T extends RegExp
|
||||
? RegExp
|
||||
: T[keyof T] extends Function
|
||||
? T
|
||||
: { -readonly [P in keyof T]: DeepWritable<T[P]> }
|
||||
|
||||
export function deepClone<T>(value: T): DeepWritable<T> {
|
||||
if (Array.isArray(value)) {
|
||||
return value.map(v => deepClone(v)) as DeepWritable<T>
|
||||
}
|
||||
if (isObject(value)) {
|
||||
const cloned: Record<string, any> = {}
|
||||
for (const key in value) {
|
||||
cloned[key] = deepClone(value[key])
|
||||
}
|
||||
return cloned as DeepWritable<T>
|
||||
}
|
||||
if (typeof value === 'function') {
|
||||
return value as DeepWritable<T>
|
||||
}
|
||||
if (value instanceof RegExp) {
|
||||
return new RegExp(value) as DeepWritable<T>
|
||||
}
|
||||
if (typeof value === 'object' && value != null) {
|
||||
throw new Error('Cannot deep clone non-plain object')
|
||||
}
|
||||
return value as DeepWritable<T>
|
||||
}
|
||||
|
||||
/**
|
||||
* Isolate configuration data without cloning plugins or runtime instances.
|
||||
* Plugins may capture their own object in hooks, so their identity must survive.
|
||||
*/
|
||||
export function cloneConfig<T>(config: T): T {
|
||||
const seen = new WeakMap<object, unknown>()
|
||||
const pluginArrays = new WeakMap<object, unknown>()
|
||||
|
||||
function clone(value: unknown, plugins = false): unknown {
|
||||
if (value === null || typeof value !== 'object') return value
|
||||
|
||||
const cache = plugins ? pluginArrays : seen
|
||||
if (cache.has(value)) return cache.get(value)
|
||||
|
||||
if (Array.isArray(value)) {
|
||||
const result: unknown[] = new Array(value.length)
|
||||
cache.set(value, result)
|
||||
value.forEach((item, index) => {
|
||||
result[index] = clone(item, plugins)
|
||||
})
|
||||
return result
|
||||
}
|
||||
|
||||
// Preserve plugin objects, promises and other opaque plugin options.
|
||||
if (plugins) return value
|
||||
|
||||
if (value instanceof RegExp) {
|
||||
const result = new RegExp(value)
|
||||
result.lastIndex = value.lastIndex
|
||||
cache.set(value, result)
|
||||
return result
|
||||
}
|
||||
|
||||
const prototype = Object.getPrototypeOf(value)
|
||||
if (prototype !== Object.prototype && prototype !== null) return value
|
||||
|
||||
const result = Object.create(prototype) as Record<PropertyKey, unknown>
|
||||
cache.set(value, result)
|
||||
for (const key of Reflect.ownKeys(value)) {
|
||||
if (!Object.prototype.propertyIsEnumerable.call(value, key)) continue
|
||||
Object.defineProperty(result, key, {
|
||||
value: clone((value as Record<PropertyKey, unknown>)[key], key === 'plugins'),
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
writable: true
|
||||
})
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
return clone(config) as T
|
||||
}
|
||||
|
||||
type AsyncFlatten<T extends unknown[]> = T extends (infer U)[] ? Exclude<Awaited<U>, U[]>[] : never
|
||||
|
||||
export async function asyncFlatten<T extends unknown[]>(arr: T): Promise<AsyncFlatten<T>> {
|
||||
do {
|
||||
arr = (await Promise.all(arr)).flat(Infinity) as any
|
||||
} while (arr.some((v: any) => v?.then))
|
||||
return arr as unknown[] as AsyncFlatten<T>
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user