muon-ui 0.14.0 → 0.16.0

package/README.md

@@ -9,74 +9,122 @@ A multi-platform GUI application framework that uses CEF as its backend.
 
 ---
 
-## What is This?
+## What is this?
 
-Have you ever thought about how to update an outdated native GUI application into a modern one?
-Replacing applications is extremely complex and has always been a challenge for us.
+Have you ever wanted to update an aging native GUI application into a modern application?
+Application replacement is extremely complex, and it has always been a hard problem.
 
-Since the causes are so varied, there is no "magic solution" that promises, "Use this method, and it'll be easily solved!"
-Even so, everyone wants to modernize their applications at the lowest possible cost.
+The causes vary widely, so there is no magic solution that makes everything easy.
+Even so, everyone wants to modernize with as little cost as possible.
 
-muon (/ˈmjuːɒn/) is a multiplatform GUI application framework that uses CEF (Chromium Embedded Framework).
-You’ve probably heard of several similar projects, such as [Electron](https://www.electronjs.org/).
+muon (pronounced "muon") is a multi-platform GUI application framework that uses CEF (Chromium Embedded Framework).
+You have probably heard of similar projects such as [Electron](https://www.electronjs.org/).
 
-To put it simply, muon is a framework that occupies the same niche as those projects.
-In other words, it’s software that allows you to implement locally running GUI applications as web applications.
+Roughly speaking, muon is framework software in the same category.
+In other words, it lets you implement local GUI applications as web applications.
 
-With muon, you can build native applications using the most advanced and widely used browser-based UI frameworks, such as React and Vue.
+With muon, you can build native applications using the most mature and widely used browser UI frameworks, such as React and Vue.
 
 ![vscode](./images/vscode.png)
 
-So, how does muon differ from earlier framework solutions?
+So how is muon different from earlier framework software?
 
-It specializes in GUI application development within a local environment by using a whitelist approach (with a "deny-by-default" policy)
-for accessing external web resources.
+muon specializes in local GUI application development by using a whitelist approach for access to external web resources.
+In practice, access is denied by default.
 
-You might think, "It's a waste to use CEF without being able to access websites around the world!"
-However, I believe that is precisely the biggest problem with existing solutions—they've become extremely complex and difficult to manage.
+You may think that using CEF without access to websites around the world is a waste.
+However, we believe that this is the biggest reason existing solutions have become very complex and difficult to handle.
 
-Furthermore, muon isn't completely unable to access external resources; since it uses a whitelist approach,
-you can still access permitted websites.
+muon also does not completely forbid access to external resources.
+Because the policy is whitelist-based, permitted websites remain accessible.
 
-It also features a plugin system that supports fully asynchronous processing, enabling interoperability with native libraries.
-Since these features become available based on pre-configured settings, there's no risk of unused functionality running unchecked.
+muon also includes a plugin system with fully asynchronous processing for interoperability with native libraries.
+These features are enabled from explicit configuration, so unused capabilities are not left open.
 
-Since it's CEF-based, you can naturally use features expected in Chromium, such as WebGL, WebGPU, WebAssembly, Web Workers, and Local Storage.
-You can also display DevTools. Because it supports CDP (Chromium DevTools Protocol), you can debug using tools like VS Code or connect and control it via Playwright.
-You can also use remote DevTools from Chromium/Chrome via `chrome://inspect/`.
+Because muon is based on CEF, Chromium features such as WebGL, WebGPU, WebAssembly, Web workers, and Local storage are available as expected.
+DevTools can be shown. CDP (Chrome DevTools Protocol) is also available, so you can debug with VS Code, connect Playwright, or control the app externally.
+You can also use remote DevTools from Chromium/Chrome through `chrome://inspect/`.
 
-In short, by clearly eliminating one of the major issues that arise when migrating native GTK/Qt/Windows applications to web applications,
-you can develop modern local GUI applications using the web-based technology ecosystem.
+In short, muon clearly removes one of the major problems that appears when migrating GTK/Qt/Windows native applications to web applications.
+This lets you build modern local GUI applications with the web technology ecosystem.
+
+muon also minimizes the steps required to create a muon application, keeping the barrier to entry low.
+With the minimal setup, installing the NPM package and adding one line to the configuration file is enough to launch your first muon app.
 
 ### Features
 
-- By restricting all network access with a whitelist filter, you can completely block problematic content.
-- It is provided as an easy-to-use NPM package, allowing you to easily turn your web application project into a native GUI application. No complex configuration or modifications are required.
-- The browser responsible for rendering is CEF (Chromium Embedded Framework). This means that, from the perspective of the web application, it is virtually equivalent to using Chromium or Chrome.
-- It supports Vite plugins. Since it supports Vite’s HMR, you can preview real-time updates during development.
-- With `muon run`, you can launch a development environment that uses local assets directly without starting an HTTP server.
-- You can include the Linux desktop launcher and icon metadata in your distribution build.
-- You can use DevTools. Furthermore, since it supports CDP (Chromium DevTools Protocol), you can perform remote debugging from an external source.
-- You can display multiple browser windows. Browser windows can also be organized into a parent-child hierarchy.
-- It features a plugin system. Plugin functionality can be restricted using a whitelist filter.
-- Using built-in plugins, you can access local files, open dialogs, launch child processes, and manipulate windows.
-- It supports packages for Linux (deb) and Windows (NSIS), as well as portable operation.
+- Restricts all network access through a whitelist filter, letting you completely exclude problematic content.
+- Provided as an easy-to-use NPM package, so you can turn your web application project into a native GUI application without complex configuration or changes.
+- The rendering browser is CEF (Chromium Embedded Framework). From the web application's point of view, this is almost the same as using Chromium or Chrome.
+- Supports the Vite plugin system. It also supports Vite HMR, so previews update in real time during development.
+- Supports Linux (deb) and Windows (NSIS) package generation, and portable distribution.
+- DevTools can be used. CDP (Chrome DevTools Protocol) is also supported, so remote debugging from external tools is possible.
+- Includes a plugin system. Plugin capabilities can also be restricted by a whitelist filter.
+- Built-in plugins provide access to local files, open dialogs, child process launching, and window operations.
 
 ### Environment
 
-- Supports the following architectures among those supported by the official CEF binaries:
-  - Linux: amd64, armv7l, arm64
+- Supports the following architectures from the official CEF binary architectures:
+  - Linux: amd64, armhf, arm64
   - Windows: i686, amd64
-- Build Environment
+- Build environment
   - Node.js 20 or later
-  - Vite 5 or later (optional)
+  - Vite 5 or later
 
 ---
 
-TODO:
+## How to enable muon on your project
+
+### Install the muon package
+
+Install the muon package, officially named `muon-ui`, into `devDependencies`:
+
+```bash
+npm install -D muon-ui
+```
+
+The muon package includes the following:
+
+- muon CLI
+- muon Vite plugin
+- TypeScript type definitions for muon built-in plugins
+- Platform-specific muon binary assets
+
+The CEF binary itself is not included in the NPM package.
+CEF is downloaded from the official CDN when it becomes necessary.
+
+### Configure the muon Vite plugin
+
+Installing the muon package almost completes the preparation, but you should enable the muon Vite plugin so that HMR (Hot Module Replacement) and muon app builds are available.
+
+For anyone unfamiliar with HMR, Vite acts as a development server, lets a browser show the page, and updates the display almost in real time when the page is edited.
+In other words, it is a very useful feature that automatically previews edit results.
+
+The muon Vite plugin supports HMR by launching muon instead of a browser and making HMR work inside the muon app.
+Add the following code to `vite.config.ts` to enable it:
+
+```ts
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import muon from 'muon-ui/vite'
+
+export default defineConfig({
+  plugins: [
+    react(),  // React plugin
+    muon(),   // muon plugin (add this)
+  ],
+})
+```
+
+Add `muon()` to the `plugins` array in the `defineConfig()` argument.
+This enables the muon Vite plugin. Preparation is now complete.
 
 ---
 
+## Documents
+
+For more information, [please visit the repository](https://github.com/kekyo/muon-ui/).
+
 ## License
 
 Under MIT.

package/dist/cli.cjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 /*!
 * name: muon-ui
-* version: 0.14.0
+* version: 0.16.0
 * description: A multi-platform GUI application framework that uses CEF as its backend
 * author: Kouji Matsui (@kekyo@mi.kekyo.net)
 * license: MIT
 * repository.url: https://github.com/kekyo/muon-ui.git
-* git.commit.hash: 90d4fe3c0d2c7ac5c81682663879ddf9966a490b
+* git.commit.hash: 33c694fe496f80cab223ce4231f3249ddf6b3dd1
 */
-const require_vite_internals = require("./vite-internals-BInO_2N9.cjs");
+const require_vite_internals = require("./vite-internals-D987wez0.cjs");
 let commander = require("commander");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
@@ -1093,8 +1093,8 @@ var packMuonApp = async (options) => {
 };
 //#endregion
 //#region src/generated/packageMetadata.ts
-var version = "0.14.0";
-var git_commit_hash = "90d4fe3c0d2c7ac5c81682663879ddf9966a490b";
+var version = "0.16.0";
+var git_commit_hash = "33c694fe496f80cab223ce4231f3249ddf6b3dd1";
 //#endregion
 //#region src/cli.ts
 var readTargetValues = (value) => {
@@ -1121,10 +1121,10 @@ var readBooleanValue = (value, label) => {
 };
 var validateEmbedConfigOptions = (options) => {
 	if (options.runtimePath !== void 0 && options.corePath !== void 0) throw new Error("Specify at most one of --runtime-path or --core-path.");
-	if (options.runtimePath === void 0 && options.corePath === void 0 && options.bootstrapPath === void 0) throw new Error("Specify at least one of --runtime-path, --core-path, or --bootstrap-path.");
+	if (options.runtimePath === void 0 && options.corePath === void 0 && options.launcherPath === void 0) throw new Error("Specify at least one of --runtime-path, --core-path, or --launcher-path.");
 	if (options.corePath !== void 0 && options.outputRuntimePath !== void 0) throw new Error("--output-runtime-path requires --runtime-path.");
 	if (options.runtimePath !== void 0 && options.output !== void 0) throw new Error("--output requires --core-path.");
-	if (options.bootstrapPath === void 0 && options.outputBootstrap !== void 0) throw new Error("--output-bootstrap requires --bootstrap-path.");
+	if (options.launcherPath === void 0 && options.outputLauncher !== void 0) throw new Error("--output-launcher requires --launcher-path.");
 };
 var createWindowsResourceOptions = (commandOptions) => {
 	const options = {};
@@ -1286,20 +1286,20 @@ var runEmbedConfigCommand = async (commandOptions) => {
 		configPath,
 		outputRuntimePath: commandOptions.outputRuntimePath
 	}) : void 0;
-	const bootstrapResult = commandOptions.bootstrapPath === void 0 ? void 0 : await require_vite_internals.embedMuonConfigInBootstrapFile({
-		bootstrapPath: commandOptions.bootstrapPath,
+	const launcherResult = commandOptions.launcherPath === void 0 ? void 0 : await require_vite_internals.embedMuonConfigInLauncherFile({
+		launcherPath: commandOptions.launcherPath,
 		configPath,
-		outputPath: commandOptions.outputBootstrap
+		outputPath: commandOptions.outputLauncher
 	});
-	if (coreResult !== void 0 && bootstrapResult !== void 0) {
+	if (coreResult !== void 0 && launcherResult !== void 0) {
 		if (commandOptions.json === true) console.log(JSON.stringify({
 			core: coreResult,
-			bootstrap: bootstrapResult
+			launcher: launcherResult
 		}, null, 2));
-		else console.log(`${coreResult.outputPath}\n${bootstrapResult.outputPath}`);
+		else console.log(`${coreResult.outputPath}\n${launcherResult.outputPath}`);
 		return;
 	}
-	const result = coreResult ?? bootstrapResult;
+	const result = coreResult ?? launcherResult;
 	if (result === void 0) throw new Error("No embed-config target was specified.");
 	printEmbedConfigResult(result, commandOptions.json);
 };
@@ -1324,7 +1324,7 @@ var createCliCommand = () => {
 	program.command("prepare").description("Prepare a muon runtime with CEF files").requiredOption("--muon-path <path>", "muon runtime file root").option("--cef-path <path>", "CEF file root").option("--stage-dir <path>", "prepared runtime output directory").option("--target <target>", "prepare target").option("--cache-dir <path>", "CEF artifact cache directory").option("--force", "rebuild an existing prepared runtime").option("-q, --quiet", "suppress native builder progress messages").option("--json", "write result as JSON").action(async (options) => {
 		await runPrepareCommand(options);
 	});
-	program.command("embed-config").description("Embed muon.json into muon runtime files").option("--runtime-path <path>", "prepared runtime directory").option("--core-path <path>", "muon-core executable path").option("--bootstrap-path <path>", "muon-bootstrap executable path").requiredOption("--config <path>", "muon config path").option("--output-runtime-path <path>", "patched runtime output directory").option("--output <path>", "patched muon-core output path").option("--output-bootstrap <path>", "patched bootstrap output path").option("--json", "write result as JSON").action(async (options) => {
+	program.command("embed-config").description("Embed muon.json into muon runtime files").option("--runtime-path <path>", "prepared runtime directory").option("--core-path <path>", "muon-core executable path").option("--launcher-path <path>", "muon-launcher executable path").requiredOption("--config <path>", "muon config path").option("--output-runtime-path <path>", "patched runtime output directory").option("--output <path>", "patched muon-core output path").option("--output-launcher <path>", "patched launcher output path").option("--json", "write result as JSON").action(async (options) => {
 		await runEmbedConfigCommand(options);
 	});
 	return program;