muon-ui 0.15.0 → 0.17.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.15.0
+* version: 0.17.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: a54e20c0496ee705422cfec16a02933146163e63
+* git.commit.hash: 1092f3c406f2ebfe9f5938ec51b70bea9f84a6ca
 */
-const require_vite_internals = require("./vite-internals-BNuD6EFm.cjs");
+const require_vite_internals = require("./vite-internals-BOAXlmwz.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.15.0";
-var git_commit_hash = "a54e20c0496ee705422cfec16a02933146163e63";
+var version = "0.17.0";
+var git_commit_hash = "1092f3c406f2ebfe9f5938ec51b70bea9f84a6ca";
 //#endregion
 //#region src/cli.ts
 var readTargetValues = (value) => {