@thatkawaiisam/electron-vite 5.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,105 @@
+<p align="center">
+  <img src="https://alex8088.github.io/assets/electron-vite.svg" width="150px" height="150px">
+</p>
+
+<div align="center">
+  <h1>electron-vite</h1>
+</div>
+<p align="center">Next generation Electron build tooling based on Vite</p>
+
+<p align="center">
+<img src="https://img.shields.io/npm/v/electron-vite?color=6988e6&label=version">
+<img src="https://img.shields.io/github/license/alex8088/electron-vite?color=blue" alt="license" />
+</p>
+
+<p align="center">
+<a href="https://electron-vite.org">Documentation</a> |
+<a href="https://electron-vite.org/guide">Getting Started</a> |
+<a href="https://github.com/alex8088/quick-start/tree/master/packages/create-electron">create-electron</a>
+</p>
+
+<p align="center">
+<a href="https://cn.electron-vite.org">中文文档</a>
+</p>
+
+<br />
+<br />
+
+## 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.
+- 📦 Out-of-the-box support for TypeScript, Vue, React, Svelte, SolidJS and more.
+
+## Usage
+
+### Install
+
+```sh
+npm i electron-vite -D
+```
+
+### Development & Build
+
+In a project where `electron-vite` is installed, you can use `electron-vite` binary directly with `npx electron-vite` or add the npm scripts to your `package.json` file like this:
+
+```json
+{
+  "scripts": {
+    "start": "electron-vite preview",
+    "dev": "electron-vite dev",
+    "prebuild": "electron-vite build"
+  }
+}
+```
+
+### Configuration
+
+When running `electron-vite` from the command line, electron-vite will automatically try to resolve a config file named `electron.vite.config.js` inside project root. The most basic config file looks like this:
+
+```js
+// electron.vite.config.js
+export default {
+  main: {
+    // vite config options
+  },
+  preload: {
+    // vite config options
+  },
+  renderer: {
+    // vite config options
+  }
+}
+```
+
+### Getting Started
+
+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
+```
+
+Currently supported template presets include:
+
+|                                                 JavaScript                                                 |                                                    TypeScript                                                    |
+| :--------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------: |
+| [vanilla](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/vanilla) | [vanilla-ts](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/vanilla-ts) |
+|     [vue](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/vue)     |     [vue-ts](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/vue-ts)     |
+|   [react](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/react)   |   [react-ts](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/react-ts)   |
+|  [svelte](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/svelte)  |  [svelte-ts](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/svelte-ts)  |
+|   [solid](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/solid)   |   [solid-ts](https://github.com/alex8088/quick-start/tree/master/packages/create-electron/playground/solid-ts)   |
+
+## Contribution
+
+See [Contributing Guide](CONTRIBUTING.md).
+
+## License
+
+[MIT](./LICENSE) © alex.wei

package/bin/electron-bytecode.cjs

@@ -0,0 +1,32 @@
+const vm = require('vm')
+const v8 = require('v8')
+const wrap = require('module').wrap
+
+v8.setFlagsFromString('--no-lazy')
+v8.setFlagsFromString('--no-flush-bytecode')
+
+let code = ''
+
+process.stdin.setEncoding('utf-8')
+
+process.stdin.on('readable', () => {
+  const data = process.stdin.read()
+  if (data !== null) {
+    code += data
+  }
+})
+
+process.stdin.on('end', () => {
+  try {
+    if (typeof code !== 'string') {
+      throw new Error(`javascript code must be string. ${typeof code} was given.`)
+    }
+
+    const script = new vm.Script(wrap(code), { produceCachedData: true })
+    const bytecodeBuffer = script.createCachedData()
+
+    process.stdout.write(bytecodeBuffer)
+  } catch (error) {
+    console.error(error)
+  }
+})

package/bin/electron-vite.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+const debugIndex = process.argv.findIndex(arg => /^(?:-d|--debug)$/.test(arg))
+const filterIndex = process.argv.findIndex(arg => /^(?:-f|--filter)$/.test(arg))
+
+if (debugIndex > 0) {
+  let value = process.argv[debugIndex + 1]
+  if (!value || value.startsWith('-')) {
+    value = 'vite:*'
+  } else {
+    value = value
+      .split(',')
+      .map(v => `vite:${v}`)
+      .join(',')
+  }
+  process.env.DEBUG = `${process.env.DEBUG ? process.env.DEBUG + ',' : ''}${value}`
+
+  if (filterIndex > 0) {
+    const filter = process.argv[filterIndex + 1]
+    if (filter && !filter.startsWith('-')) {
+      process.env.VITE_DEBUG_FILTER = filter
+    }
+  }
+}
+
+function run() {
+  import('../dist/cli.js')
+}
+
+run()

package/dist/chunks/lib-6iOrRH4E.js

@@ -0,0 +1,38 @@
+import { build as build$1 } from 'vite';
+import { r as resolveConfig } from './lib-D8_qgfjp.js';
+import 'node:path';
+import 'node:fs';
+import 'node:url';
+import 'node:module';
+import 'picocolors';
+import 'esbuild';
+import 'node:child_process';
+import 'node:crypto';
+import 'node:fs/promises';
+import 'magic-string';
+import '@babel/core';
+
+/**
+ * Bundles the electron app for production.
+ */
+async function build(inlineConfig = {}) {
+    process.env.NODE_ENV_ELECTRON_VITE = 'production';
+    const config = await resolveConfig(inlineConfig, 'build', 'production');
+    if (!config.config) {
+        return;
+    }
+    // Build targets in order: main -> preload -> renderer
+    const buildTargets = ['main', 'preload', 'renderer'];
+    for (const target of buildTargets) {
+        const viteConfig = config.config[target];
+        if (viteConfig) {
+            // Disable watch mode in production builds
+            if (viteConfig.build?.watch) {
+                viteConfig.build.watch = null;
+            }
+            await build$1(viteConfig);
+        }
+    }
+}
+
+export { build };

package/dist/chunks/lib-B1EDBNjL.js

@@ -0,0 +1,110 @@
+import { createLogger, createServer as createServer$1, mergeConfig, build } from 'vite';
+import colors from 'picocolors';
+import { r as resolveConfig, c as resolveHostname, s as startElectron } from './lib-D8_qgfjp.js';
+import 'node:path';
+import 'node:fs';
+import 'node:url';
+import 'node:module';
+import 'esbuild';
+import 'node:child_process';
+import 'node:crypto';
+import 'node:fs/promises';
+import 'magic-string';
+import '@babel/core';
+
+async function createServer(inlineConfig = {}, options) {
+    process.env.NODE_ENV_ELECTRON_VITE = 'development';
+    const config = await resolveConfig(inlineConfig, 'serve', 'development');
+    if (config.config) {
+        const logger = createLogger(inlineConfig.logLevel);
+        let server;
+        let ps;
+        const errorHook = (e) => {
+            logger.error(`${colors.bgRed(colors.white(' ERROR '))} ${colors.red(e.message)}`);
+        };
+        const mainViteConfig = config.config?.main;
+        if (mainViteConfig && !options.rendererOnly) {
+            const watchHook = () => {
+                logger.info(colors.green(`\nelectron main process rebuilt successfully`));
+                if (ps) {
+                    ps.removeAllListeners();
+                    ps.kill();
+                    ps = startElectron(inlineConfig.root);
+                    logger.info(colors.green(`\nrestarting electron app...\n`));
+                }
+            };
+            await doBuild(mainViteConfig, watchHook, errorHook);
+            logger.info(colors.green(`\nelectron main process built successfully`));
+        }
+        const preloadViteConfig = config.config?.preload;
+        if (preloadViteConfig && !options.rendererOnly) {
+            logger.info(colors.gray(`\n-----\n`));
+            const watchHook = () => {
+                logger.info(colors.green(`\nelectron preload scripts rebuilt successfully`));
+                if (server) {
+                    logger.info(colors.cyan(`\nreloading electron renderer...\n`));
+                    server.ws.send({ type: 'full-reload' });
+                }
+            };
+            await doBuild(preloadViteConfig, watchHook, errorHook);
+            logger.info(colors.green(`\nelectron preload scripts built successfully`));
+        }
+        if (options.rendererOnly) {
+            logger.warn(`\n${colors.yellow(colors.bold('(!)'))} ${colors.yellow('skipped building main process and preload scripts (using previous build)')}`);
+        }
+        const rendererViteConfig = config.config?.renderer;
+        if (rendererViteConfig) {
+            logger.info(colors.gray(`\n-----\n`));
+            server = await createServer$1(rendererViteConfig);
+            if (!server.httpServer) {
+                throw new Error('HTTP server not available');
+            }
+            await server.listen();
+            const conf = server.config.server;
+            const protocol = conf.https ? 'https:' : 'http:';
+            const host = resolveHostname(conf.host);
+            const port = conf.port;
+            process.env.ELECTRON_RENDERER_URL = `${protocol}//${host}:${port}`;
+            const slogger = server.config.logger;
+            slogger.info(colors.green(`dev server running for the electron renderer process at:\n`), {
+                clear: !slogger.hasWarned && !options.rendererOnly
+            });
+            server.printUrls();
+        }
+        ps = startElectron(inlineConfig.root);
+        logger.info(colors.green(`\nstarting electron app...\n`));
+    }
+}
+async function doBuild(config, watchHook, errorHook) {
+    return new Promise(resolve => {
+        if (config.build?.watch) {
+            let firstBundle = true;
+            const closeBundle = () => {
+                if (firstBundle) {
+                    firstBundle = false;
+                    resolve();
+                }
+                else {
+                    watchHook();
+                }
+            };
+            config = mergeConfig(config, {
+                plugins: [
+                    {
+                        name: 'vite:electron-watcher',
+                        closeBundle
+                    }
+                ]
+            });
+        }
+        build(config)
+            .then(() => {
+            if (!config.build?.watch) {
+                resolve();
+            }
+        })
+            .catch(e => errorHook(e));
+    });
+}
+
+export { createServer };

package/dist/chunks/lib-CKGCTpsN.js

@@ -0,0 +1,25 @@
+import colors from 'picocolors';
+import { createLogger } from 'vite';
+import { s as startElectron } from './lib-D8_qgfjp.js';
+import { build } from './lib-6iOrRH4E.js';
+import 'node:path';
+import 'node:fs';
+import 'node:url';
+import 'node:module';
+import 'esbuild';
+import 'node:child_process';
+import 'node:crypto';
+import 'node:fs/promises';
+import 'magic-string';
+import '@babel/core';
+
+async function preview(inlineConfig = {}, options) {
+    if (!options.skipBuild) {
+        await build(inlineConfig);
+    }
+    const logger = createLogger(inlineConfig.logLevel);
+    startElectron(inlineConfig.root);
+    logger.info(colors.green(`\nstarting electron app...\n`));
+}
+
+export { preview };