muon-ui 0.20.0 → 0.22.0

package/README.md

@@ -17,7 +17,7 @@ Application replacement is extremely complex, and it has always been a hard prob
 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 (pronounced "muon") is a multi-platform GUI application framework that uses CEF (Chromium Embedded Framework).
+muon (/ˈmjuːɒn/) 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/).
 
 Roughly speaking, muon is framework software in the same category.
@@ -73,35 +73,36 @@ With the minimal setup, installing the NPM package and adding one line to the co
 
 ---
 
-## How to enable muon on your project
+## Getting started with muon (Quick version)
 
-### Install the muon package
-
-Install the muon package, officially named `muon-ui`, into `devDependencies`:
+Let's get started by creating an application with muon (a muon app).
+Use a [Vite template](https://vite.dev/guide/) to create "my-muon-app" as you normally would:
 
 ```bash
-npm install -D muon-ui
+npm create vite@latest my-muon-app -- --template react-ts
 ```
 
-The muon package includes the following:
+This example uses React + TypeScript, but of course other choices are fine. Be sure to enable TypeScript.
+Then run:
 
-- muon CLI
-- muon Vite plugin
-- TypeScript type definitions for muon built-in plugins
-- Platform-specific muon binary assets
+```bash
+cd my-muon-app
+npm install
+npm run dev
+```
 
-The CEF binary itself is not included in the NPM package.
-CEF is downloaded from the official CDN when it becomes necessary.
+This starts the Vite development server, and you can click the link to view the page in a browser.
 
-### Configure the muon Vite plugin
+Now add muon to this project:
 
-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.
+```bash
+npm install -D muon-ui
+```
 
-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 CEF binary itself is not included in the NPM package.
+CEF is downloaded from the official CDN when it is needed.
 
-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:
+Next, add the muon Vite plugin to Vite so that you can build your muon app. Add the following code to `vite.config.ts`:
 
 ```ts
 import { defineConfig } from 'vite'
@@ -116,8 +117,13 @@ export default defineConfig({
 })
 ```
 
-Add `muon()` to the `plugins` array in the `defineConfig()` argument.
-This enables the muon Vite plugin. Preparation is now complete.
+Everything is now ready. Launch muon:
+
+```bash
+npm run dev
+```
+
+The muon window should appear with your page!
 
 ---
 

package/dist/cli.cjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 /*!
 * name: muon-ui
-* version: 0.20.0
+* version: 0.22.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: 4140a0c778334d15a6cf3a83861ed006e81543bb
+* git.commit.hash: 5c8d38ea864ba1916f26e6beb6814a4af57479d7
 */
-const require_vite_internals = require("./vite-internals-DpXCyV08.cjs");
+const require_vite_internals = require("./vite-internals-BA4riWRd.cjs");
 let commander = require("commander");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
@@ -115,12 +115,18 @@ var copyViteOutputAsRunAssets = async (project, assetSourcePath, assetPrefix) =>
 	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(destinationPath), { recursive: true });
 	await (0, node_fs_promises.cp)(project.viteOutputDirectory, destinationPath, { recursive: true });
 };
-var prepareViteRunAssets = async (cwd) => {
+var prepareViteRunAssets = async (cwd, configPath) => {
 	const project = await require_vite_internals.loadMuonBuildSequenceProject(cwd);
 	if (project.pluginOptions === void 0) return;
 	const buildOptions = require_vite_internals.resolveMuonViteBuildOptions(project.pluginOptions);
 	const packagedAssetOptions = require_vite_internals.createVitePackagedAssetOptions(project.viteBase ?? "/");
 	const assetSourcePath = (0, node_path.join)(project.root, ".muon", "run", "assets");
+	const effectiveConfigPath = configPath ?? buildOptions.configPath;
+	const projectConfig = await resolveProjectConfig(project.root, effectiveConfigPath);
+	const nodeProject = await require_vite_internals.resolveMuonNodeProject(projectConfig.config, projectConfig.configPath === void 0 ? project.root : (0, node_path.dirname)(projectConfig.configPath));
+	if (project.viteOutputDirectory === void 0) throw new Error("Vite output directory could not be resolved.");
+	await require_vite_internals.assertMuonNodeProjectViteBuildIsSafe(nodeProject, project.viteOutputDirectory, project.vitePublicDirectory ?? "");
+	await require_vite_internals.assertMuonNodeProjectAssetSourceIsSafe(nodeProject, assetSourcePath);
 	await (0, node_fs_promises.rm)(assetSourcePath, {
 		recursive: true,
 		force: true
@@ -130,7 +136,7 @@ var prepareViteRunAssets = async (cwd) => {
 	return {
 		root: project.root,
 		pluginOptions: project.pluginOptions,
-		configPath: buildOptions.configPath,
+		configPath: effectiveConfigPath,
 		assetSourcePath,
 		browserStartPage: packagedAssetOptions.browserStartPage,
 		runtimePluginConfig,
@@ -221,7 +227,7 @@ var resolveAssetSource = async (root, assetSourcePath, projectConfig) => {
 		overrideAssetSourcePath: defaultAssetSourcePath
 	};
 };
-var createMuonDevOverrideConfig = (assetSourcePath, enableDebugger, browserStartPage, runtimePluginConfig) => {
+var createMuonDevOverrideConfig = (assetSourcePath, enableDebugger, browserStartPage, runtimePluginConfig, nodeProjectPath) => {
 	const browser = browserStartPage === void 0 && !enableDebugger ? void 0 : {
 		...browserStartPage === void 0 ? {} : { startPage: browserStartPage },
 		...enableDebugger ? { keybind: {
@@ -231,6 +237,7 @@ var createMuonDevOverrideConfig = (assetSourcePath, enableDebugger, browserStart
 	};
 	return {
 		...assetSourcePath === void 0 ? {} : { asset: { sourcePath: assetSourcePath } },
+		...nodeProjectPath === void 0 ? {} : { node: { project: nodeProjectPath } },
 		...enableDebugger ? { cdp: { enable: true } } : {},
 		...browser === void 0 ? {} : { browser },
 		...runtimePluginConfig === void 0 ? {} : { plugin: runtimePluginConfig }
@@ -258,7 +265,7 @@ var runMuonExecutable = async (muonExecutablePath, configPaths, allowInsecureLoc
 	});
 };
 var runMuonDevOnce = async (options, cwd, reportViteServerProxyWarning) => {
-	const preparedViteAssets = options.assetSourcePath === void 0 ? await prepareViteRunAssets(cwd) : void 0;
+	const preparedViteAssets = options.assetSourcePath === void 0 ? await prepareViteRunAssets(cwd, options.configPath) : void 0;
 	const loadedViteOptions = preparedViteAssets === void 0 ? await loadViteMuonOptions(cwd) : {
 		root: preparedViteAssets.root,
 		pluginOptions: preparedViteAssets.pluginOptions,
@@ -281,12 +288,15 @@ var runMuonDevOnce = async (options, cwd, reportViteServerProxyWarning) => {
 	const enableDebugger = options.enableDebugger ?? pluginOptions?.enableDebugger ?? true;
 	const allowInsecureLocalhost = options.allowInsecureLocalhost ?? pluginOptions?.allowInsecureLocalhost ?? false;
 	const projectConfig = await resolveProjectConfig(root, options.configPath ?? preparedViteAssets?.configPath);
+	const nodeProject = await require_vite_internals.resolveMuonNodeProject(projectConfig.config, projectConfig.configPath === void 0 ? root : (0, node_path.dirname)(projectConfig.configPath));
 	const asset = preparedViteAssets === void 0 ? await resolveAssetSource(root, options.assetSourcePath, projectConfig) : {
 		assetSourcePath: preparedViteAssets.assetSourcePath,
 		overrideAssetSourcePath: preparedViteAssets.assetSourcePath
 	};
 	const browserStartPage = preparedViteAssets?.browserStartPage !== void 0 && !hasConfigBrowserStartPage(projectConfig.config) ? preparedViteAssets.browserStartPage : void 0;
 	const overrideConfigPath = (0, node_path.join)(root, ".muon", "run", "muon.run.json");
+	await require_vite_internals.assertMuonNodeProjectStagingIsSafe(nodeProject, stagePath);
+	await require_vite_internals.assertMuonNodeProjectAssetSourceIsSafe(nodeProject, asset.assetSourcePath);
 	await require_vite_internals.ensureMuonGitignoreEntry(root);
 	const preparedRuntime = await require_vite_internals.runMuonPrepare({
 		muonPath,
@@ -294,6 +304,7 @@ var runMuonDevOnce = async (options, cwd, reportViteServerProxyWarning) => {
 		stageDir: stagePath,
 		target,
 		cacheDir: environment.MUON_CACHE_DIR,
+		nodeRuntimeRequirement: require_vite_internals.createMuonNodeRuntimeRequirement(nodeProject, true),
 		force: false,
 		quiet: options.quietPrepare === true,
 		prepareExecutablePath: void 0,
@@ -301,7 +312,9 @@ var runMuonDevOnce = async (options, cwd, reportViteServerProxyWarning) => {
 		cwd: root
 	});
 	if (preparedRuntime.stagePath === void 0) throw new Error("muon-builder did not return a staged runtime path.");
-	await writeMuonDevOverrideConfig(overrideConfigPath, createMuonDevOverrideConfig(asset.overrideAssetSourcePath, enableDebugger, browserStartPage, preparedViteAssets?.runtimePluginConfig));
+	const nodeProjectPath = await require_vite_internals.stageMuonNodeProject(nodeProject, preparedRuntime.stagePath);
+	if (nodeProjectPath !== void 0) await require_vite_internals.assertMuonNodeHostArtifacts(preparedRuntime.stagePath, platform);
+	await writeMuonDevOverrideConfig(overrideConfigPath, createMuonDevOverrideConfig(asset.overrideAssetSourcePath, enableDebugger, browserStartPage, preparedViteAssets?.runtimePluginConfig, nodeProjectPath));
 	const muonExecutablePath = require_vite_internals.getMuonExecutablePath(preparedRuntime.stagePath, platform);
 	const exitCode = await runMuonExecutable(muonExecutablePath, [...projectConfig.configPath === void 0 ? [] : [projectConfig.configPath], overrideConfigPath], allowInsecureLocalhost, environment);
 	return {
@@ -1006,7 +1019,11 @@ var packMuonApp = async (options) => {
 	if (linuxDesktopOptions !== void 0) buildOptions.linuxDesktop = linuxDesktopOptions;
 	if (progress !== void 0) buildOptions.progress = progress;
 	buildOptions.environment = environment;
-	const windowsResourceConfig = await require_vite_internals.readMuonConfigForWindowsResource(root, options.configPath);
+	const windowsResourceConfig = await require_vite_internals.readMuonConfigForWindowsResource(root, options.configPath ?? pluginBuildOptions.configPath);
+	const nodeProject = await require_vite_internals.resolveMuonNodeProject(windowsResourceConfig.config, windowsResourceConfig.directory);
+	await require_vite_internals.assertMuonNodeProjectPackCleanupIsSafe(nodeProject, packageBuildRoot);
+	await require_vite_internals.assertMuonNodeProjectPackCleanupIsSafe(nodeProject, (0, node_path.join)(artifactsRoot, "deb"));
+	await require_vite_internals.assertMuonNodeProjectPackCleanupIsSafe(nodeProject, (0, node_path.join)(artifactsRoot, "nsis"));
 	const windowsResource = await require_vite_internals.resolveMuonWindowsResource({
 		root,
 		packageDirectory: options.packageDirectory ?? pluginBuildOptions.packageDirectory ?? "",
@@ -1108,8 +1125,8 @@ var packMuonApp = async (options) => {
 };
 //#endregion
 //#region src/generated/packageMetadata.ts
-var version = "0.20.0";
-var git_commit_hash = "4140a0c778334d15a6cf3a83861ed006e81543bb";
+var version = "0.22.0";
+var git_commit_hash = "5c8d38ea864ba1916f26e6beb6814a4af57479d7";
 //#endregion
 //#region src/cli.ts
 var readTargetValues = (value) => {
@@ -1256,6 +1273,7 @@ var runPrepareCommand = async (commandOptions) => {
 		stageDir: commandOptions.stageDir,
 		target: commandOptions.target ?? require_vite_internals.getDefaultMuonPrepareTarget(process.platform, process.arch),
 		cacheDir: commandOptions.cacheDir,
+		nodeRuntimeRequirement: void 0,
 		force: commandOptions.force === true,
 		quiet: commandOptions.quiet === true,
 		prepareExecutablePath: void 0,