muon-ui 0.6.0 → 0.7.0

package/dist/vite.mjs

@@ -1,11 +1,11 @@
 /*!
 * name: muon-ui
-* version: 0.6.0
+* version: 0.7.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: 44340328835f0d4ee860b444916971dfa03486ef
+* git.commit.hash: fe80718aaa617c0c0ea5c816bbe38d22bf2e8402
 */
 import { basename, dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { constants, writeFileSync } from "node:fs";
@@ -1554,6 +1554,144 @@ var embedMuonConfigInRuntime = async ({ runtimePath, configPath, outputRuntimePa
 	});
 };
 //#endregion
+//#region src/targets.ts
+/**
+* Supported public Muon targets in deterministic build order.
+*/
+var allMuonTargets = [
+	"linux-amd64",
+	"linux-armhf",
+	"linux-arm64",
+	"windows-i686",
+	"windows-amd64"
+];
+var targetDescriptors = {
+	"linux-amd64": {
+		id: "linux-amd64",
+		cefTarget: "linux64",
+		os: "linux",
+		arch: "amd64",
+		distributionDirectoryName: "dist-muon-linux-amd64",
+		runtimeExecutableName: "muon-core",
+		bootstrapExecutableName: "muon-bootstrap",
+		launcherExtension: "",
+		runtimeFiles: [
+			"muon-core",
+			"libmuon-ui.so",
+			"libcardio.so"
+		]
+	},
+	"linux-armhf": {
+		id: "linux-armhf",
+		cefTarget: "linuxarm",
+		os: "linux",
+		arch: "armhf",
+		distributionDirectoryName: "dist-muon-linux-armhf",
+		runtimeExecutableName: "muon-core",
+		bootstrapExecutableName: "muon-bootstrap",
+		launcherExtension: "",
+		runtimeFiles: [
+			"muon-core",
+			"libmuon-ui.so",
+			"libcardio.so"
+		]
+	},
+	"linux-arm64": {
+		id: "linux-arm64",
+		cefTarget: "linuxarm64",
+		os: "linux",
+		arch: "arm64",
+		distributionDirectoryName: "dist-muon-linux-arm64",
+		runtimeExecutableName: "muon-core",
+		bootstrapExecutableName: "muon-bootstrap",
+		launcherExtension: "",
+		runtimeFiles: [
+			"muon-core",
+			"libmuon-ui.so",
+			"libcardio.so"
+		]
+	},
+	"windows-i686": {
+		id: "windows-i686",
+		cefTarget: "windows32",
+		os: "windows",
+		arch: "i686",
+		distributionDirectoryName: "dist-muon-windows-i686",
+		runtimeExecutableName: "muon-core.exe",
+		bootstrapExecutableName: "muon-bootstrap.exe",
+		launcherExtension: ".exe",
+		runtimeFiles: [
+			"muon-core.exe",
+			"libmuon-ui.dll",
+			"libcardio.dll"
+		],
+		optionalRuntimeFilePatterns: [
+			/^libgcc_s_.*-1\.dll$/,
+			/^libstdc\+\+-6\.dll$/,
+			/^libwinpthread-1\.dll$/
+		]
+	},
+	"windows-amd64": {
+		id: "windows-amd64",
+		cefTarget: "windows64",
+		os: "windows",
+		arch: "amd64",
+		distributionDirectoryName: "dist-muon-windows-amd64",
+		runtimeExecutableName: "muon-core.exe",
+		bootstrapExecutableName: "muon-bootstrap.exe",
+		launcherExtension: ".exe",
+		runtimeFiles: [
+			"muon-core.exe",
+			"libmuon-ui.dll",
+			"libcardio.dll"
+		],
+		optionalRuntimeFilePatterns: [
+			/^libgcc_s_.*-1\.dll$/,
+			/^libstdc\+\+-6\.dll$/,
+			/^libwinpthread-1\.dll$/
+		]
+	}
+};
+Object.fromEntries(allMuonTargets.map((target) => [targetDescriptors[target].cefTarget, target]));
+/**
+* Returns metadata for a public Muon target.
+*
+* @param target Public Muon target.
+* @returns Target descriptor.
+*/
+var getMuonTargetDescriptor = (target) => targetDescriptors[target];
+/**
+* Normalizes a user supplied public Muon target.
+*
+* @param target Target value supplied by the user.
+* @param label Error label used in diagnostics.
+* @returns Public Muon target.
+*/
+var normalizeMuonTarget = (target, label = "Muon target") => {
+	const normalized = target.trim().toLowerCase();
+	if (allMuonTargets.includes(normalized)) return normalized;
+	throw new Error(`Unsupported ${label}: ${target}`);
+};
+/**
+* Resolves a Node platform and architecture pair to a public Muon target.
+*
+* @param platform Node platform.
+* @param architecture Node architecture.
+* @returns Public Muon target.
+*/
+var getDefaultMuonTarget = (platform, architecture) => {
+	if (platform === "win32") {
+		if (architecture === "ia32") return "windows-i686";
+		if (architecture === "x64") return "windows-amd64";
+	}
+	if (platform === "linux") {
+		if (architecture === "x64") return "linux-amd64";
+		if (architecture === "arm") return "linux-armhf";
+		if (architecture === "arm64") return "linux-arm64";
+	}
+	throw new Error(`Unsupported Muon target: platform=${platform}, arch=${architecture}`);
+};
+//#endregion
 //#region src/prepare.ts
 /**
 * Returns the default Muon prepare target for a Node platform and architecture.
@@ -1563,16 +1701,11 @@ var embedMuonConfigInRuntime = async ({ runtimePath, configPath, outputRuntimePa
 * @returns Muon prepare target name.
 */
 var getDefaultMuonPrepareTarget = (platform, architecture) => {
-	if (platform === "win32") {
-		if (architecture === "ia32") return "windows32";
-		if (architecture === "x64") return "windows64";
-	}
-	if (platform === "linux") {
-		if (architecture === "x64") return "linux64";
-		if (architecture === "arm") return "linuxarm";
-		if (architecture === "arm64") return "linuxarm64";
+	try {
+		return getDefaultMuonTarget(platform, architecture);
+	} catch {
+		throw new Error(`Unsupported Muon prepare target: platform=${platform}, arch=${architecture}`);
 	}
-	throw new Error(`Unsupported Muon prepare target: platform=${platform}, arch=${architecture}`);
 };
 var getPrepareExecutableName = (platform) => platform === "win32" ? "muon-prepare.exe" : "muon-prepare";
 var moduleDirectory$2 = typeof __dirname === "string" ? __dirname : dirname(fileURLToPath(import.meta.url));
@@ -1602,7 +1735,7 @@ var createMuonPrepareArguments = (options) => {
 	];
 	if (options.cefPath !== void 0) args.push("--cef-path", options.cefPath);
 	if (options.stageDir !== void 0) args.push("--stage-dir", options.stageDir);
-	if (options.target !== void 0) args.push("--target", options.target);
+	if (options.target !== void 0) args.push("--target", normalizeMuonTarget(options.target, "Muon prepare target"));
 	if (options.cacheDir !== void 0) args.push("--cache-dir", options.cacheDir);
 	if (options.force) args.push("--force");
 	if (options.quiet) args.push("--quiet");
@@ -1673,107 +1806,6 @@ function __resolveDefaultExport(module, isESM) {
 	}
 	return hasDefault ? resolvedDefault ?? module : module;
 }
-var allTargets = [
-	"linux64",
-	"linuxarm",
-	"linuxarm64",
-	"windows32",
-	"windows64"
-];
-var targetAliases = {
-	linux64: "linux64",
-	"linux-amd64": "linux64",
-	"linux-x64": "linux64",
-	amd64: "linux64",
-	x64: "linux64",
-	linuxarm: "linuxarm",
-	"linux-arm": "linuxarm",
-	"linux-armv7l": "linuxarm",
-	arm: "linuxarm",
-	armv7l: "linuxarm",
-	linuxarm64: "linuxarm64",
-	"linux-arm64": "linuxarm64",
-	"linux-aarch64": "linuxarm64",
-	arm64: "linuxarm64",
-	aarch64: "linuxarm64",
-	windows32: "windows32",
-	"windows-i686": "windows32",
-	"windows-ia32": "windows32",
-	win32: "windows32",
-	i686: "windows32",
-	ia32: "windows32",
-	windows64: "windows64",
-	"windows-amd64": "windows64",
-	"windows-x64": "windows64",
-	win64: "windows64"
-};
-var targetDescriptors = {
-	linux64: {
-		distributionDirectoryName: "dist-linux-amd64",
-		runtimeExecutableName: "muon-core",
-		bootstrapExecutableName: "muon-bootstrap",
-		launcherExtension: "",
-		runtimeFiles: [
-			"muon-core",
-			"libmuon-ui.so",
-			"libcardio.so"
-		]
-	},
-	linuxarm: {
-		distributionDirectoryName: "dist-linux-armv7l",
-		runtimeExecutableName: "muon-core",
-		bootstrapExecutableName: "muon-bootstrap",
-		launcherExtension: "",
-		runtimeFiles: [
-			"muon-core",
-			"libmuon-ui.so",
-			"libcardio.so"
-		]
-	},
-	linuxarm64: {
-		distributionDirectoryName: "dist-linux-arm64",
-		runtimeExecutableName: "muon-core",
-		bootstrapExecutableName: "muon-bootstrap",
-		launcherExtension: "",
-		runtimeFiles: [
-			"muon-core",
-			"libmuon-ui.so",
-			"libcardio.so"
-		]
-	},
-	windows32: {
-		distributionDirectoryName: "dist-windows-i686",
-		runtimeExecutableName: "muon-core.exe",
-		bootstrapExecutableName: "muon-bootstrap.exe",
-		launcherExtension: ".exe",
-		runtimeFiles: [
-			"muon-core.exe",
-			"libmuon-ui.dll",
-			"libcardio.dll"
-		],
-		optionalRuntimeFilePatterns: [
-			/^libgcc_s_.*-1\.dll$/,
-			/^libstdc\+\+-6\.dll$/,
-			/^libwinpthread-1\.dll$/
-		]
-	},
-	windows64: {
-		distributionDirectoryName: "dist-windows-amd64",
-		runtimeExecutableName: "muon-core.exe",
-		bootstrapExecutableName: "muon-bootstrap.exe",
-		launcherExtension: ".exe",
-		runtimeFiles: [
-			"muon-core.exe",
-			"libmuon-ui.dll",
-			"libcardio.dll"
-		],
-		optionalRuntimeFilePatterns: [
-			/^libgcc_s_.*-1\.dll$/,
-			/^libstdc\+\+-6\.dll$/,
-			/^libwinpthread-1\.dll$/
-		]
-	}
-};
 var defaultConfigFileNames = [
 	"muon.json5",
 	"muon.jsonc",
@@ -1781,6 +1813,7 @@ var defaultConfigFileNames = [
 ];
 var appConfigSourcePath = "./assets.zip";
 var defaultAppName = "muon-app";
+var defaultAppId = "muon-app";
 var muonLicenseFileName = "CREDITS.md";
 var directoryMode = 493;
 var executableMode = 493;
@@ -1790,17 +1823,13 @@ var moduleDirectory$1 = typeof __dirname === "string" ? __dirname : dirname(file
 * Returns the host target used by muon build when no explicit target is passed.
 */
 var getDefaultMuonBuildTarget = () => {
-	return normalizeMuonBuildTarget(getDefaultMuonPrepareTarget(process.platform, process.arch));
+	return getDefaultMuonPrepareTarget(process.platform, process.arch);
 };
 /**
-* Normalizes a user-facing target alias into the npm package target name.
+* Normalizes a user-facing public target identifier.
 */
 var normalizeMuonBuildTarget = (target) => {
-	const normalized = target.trim().toLowerCase();
-	if (normalized === "linux-i686" || normalized === "linux-ia32") throw new Error("Linux i686 is not supported by muon build.");
-	const resolvedTarget = targetAliases[normalized];
-	if (resolvedTarget === void 0) throw new Error(`Unsupported muon build target: ${target}`);
-	return resolvedTarget;
+	return normalizeMuonTarget(target, "muon build target");
 };
 /**
 * Builds CEF-free Muon app distribution directories for one or more targets.
@@ -1810,7 +1839,9 @@ var buildMuonApp = async (options = {}) => {
 	const packageDirectory = resolvePackageDirectory(options.packageDirectory);
 	const targets = resolveBuildTargets(options);
 	const outputRoot = resolve(root, options.outputRoot ?? ".");
-	const appName = await resolveAppName(root, options.appName);
+	const packageJson = await readPackageJson(root);
+	const appName = resolveAppName(packageJson, options.appName);
+	const appId = resolveAppId(packageJson, options.appId);
 	const buildConfig = await readBuildConfig(root, options.configPath);
 	const assetInput = resolveAssetInput(root, options.assetSourcePath, options.assetPrefix, buildConfig);
 	const salt = Buffer.from(options.assetSalt ?? randomBytes(assetSaltByteLength));
@@ -1820,6 +1851,7 @@ var buildMuonApp = async (options = {}) => {
 			packageDirectory,
 			outputRoot,
 			appName,
+			appId,
 			target,
 			assetInput,
 			sourceConfig: buildConfig.config,
@@ -1830,6 +1862,7 @@ var buildMuonApp = async (options = {}) => {
 	return {
 		root,
 		appName,
+		appId,
 		targets: results
 	};
 };
@@ -1838,9 +1871,9 @@ var resolvePackageDirectory = (packageDirectory) => {
 	return moduleDirectory$1;
 };
 var resolveBuildTargets = (options) => {
-	if (options.allTargets === true) return [...allTargets];
+	if (options.allTargets === true) return [...allMuonTargets];
 	if (options.targets !== void 0 && options.targets.length > 0) return [...new Set(options.targets.map((target) => normalizeMuonBuildTarget(target)))];
-	if (options.allTargets !== false) return [...allTargets];
+	if (options.allTargets !== false) return [...allMuonTargets];
 	return [getDefaultMuonBuildTarget()];
 };
 var resolveAssetInput = (root, assetSourcePath, assetPrefix, buildConfig) => {
@@ -1854,16 +1887,31 @@ var normalizeZipPrefix = (prefix) => {
 	const normalized = prefix.replaceAll("\\", "/").split("/").filter((part) => part.length > 0).join("/");
 	return normalized.length > 0 ? `${normalized}/` : "";
 };
-var resolveAppName = async (root, appName) => {
+var readPackageJson = async (root) => {
+	const packageJsonPath = join(root, "package.json");
+	if (!await fileExists$1(packageJsonPath)) return {};
+	return await readJsonObjectFile(packageJsonPath, "package.json");
+};
+var resolvePackageName = (packageJson) => {
+	return typeof packageJson.name === "string" ? packageJson.name : defaultAppName;
+};
+var resolveAppName = (packageJson, appName) => {
 	if (appName !== void 0) return sanitizeAppName(appName);
-	const packageJson = await readJsonObjectFile(join(root, "package.json"), "package.json");
-	const packageName = typeof packageJson.name === "string" ? packageJson.name : defaultAppName;
+	const packageName = resolvePackageName(packageJson);
 	return sanitizeAppName(packageName.startsWith("@") ? packageName.slice(packageName.indexOf("/") + 1) : packageName);
 };
 var sanitizeAppName = (name) => {
 	const sanitized = name.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[.-]+/g, "").replace(/[.-]+$/g, "");
 	return sanitized.length > 0 ? sanitized : defaultAppName;
 };
+var resolveAppId = (packageJson, appId) => {
+	if (appId !== void 0) return sanitizeAppId(appId);
+	return sanitizeAppId(resolvePackageName(packageJson));
+};
+var sanitizeAppId = (value) => {
+	const sanitized = (value.startsWith("@") ? value.slice(1) : value).trim().toLowerCase().replace("/", ".").replace(/[^a-z0-9._-]+/g, ".").replace(/^[.]+/g, "").replace(/[.]+$/g, "");
+	return sanitized.length > 0 ? sanitized : defaultAppId;
+};
 var readBuildConfig = async (root, configPath) => {
 	const resolvedConfigPath = await resolveConfigPath(root, configPath);
 	if (resolvedConfigPath === void 0) return {
@@ -1912,7 +1960,7 @@ var readJsonObjectFile = async (filePath, label) => {
 	return parsed;
 };
 var buildMuonTarget = async (input) => {
-	const descriptor = targetDescriptors[input.target];
+	const descriptor = getMuonTargetDescriptor(input.target);
 	const sourceRuntimePath = join(input.packageDirectory, "runtime", input.target);
 	const sourceBootstrapPath = join(input.packageDirectory, "native", input.target, descriptor.bootstrapExecutableName);
 	const outputPath = join(input.outputRoot, descriptor.distributionDirectoryName);
@@ -1937,7 +1985,7 @@ var buildMuonTarget = async (input) => {
 	await copyFile(sourceBootstrapPath, launcherPath);
 	await chmod(launcherPath, executableMode);
 	const asset = await writeAssetArchive(input.assetInput, assetZipPath, input.salt);
-	const embeddedConfig = createEmbeddedConfig(input.sourceConfig, asset);
+	const embeddedConfig = createEmbeddedConfig(input.sourceConfig, asset, input.appId);
 	await withTemporaryConfig(embeddedConfig, async (configPath) => {
 		await embedMuonConfigInRuntime({
 			runtimePath: outputPath,
@@ -2031,9 +2079,11 @@ var createZipArchive = (entries) => {
 	for (const entry of entries) zip.addFile(entry.name, entry.data);
 	return zip.toBuffer();
 };
-var createEmbeddedConfig = (sourceConfig, asset) => {
+var createEmbeddedConfig = (sourceConfig, asset, appId) => {
 	const sourceAsset = sourceConfig.asset;
 	if (sourceAsset !== void 0 && !isJsonObject$1(sourceAsset)) throw new Error("muon.json asset must be an object when present.");
+	const sourceBootstrap = sourceConfig.bootstrap;
+	if (sourceBootstrap !== void 0 && !isJsonObject$1(sourceBootstrap)) throw new Error("muon.json bootstrap must be an object when present.");
 	return {
 		...sourceConfig,
 		asset: {
@@ -2041,6 +2091,10 @@ var createEmbeddedConfig = (sourceConfig, asset) => {
 			sourcePath: appConfigSourcePath,
 			signature: asset.signature,
 			salt: asset.salt
+		},
+		bootstrap: {
+			...sourceBootstrap ?? {},
+			appId
 		}
 	};
 };
@@ -2086,11 +2140,35 @@ var isJsonObject$1 = (value) => {
 var getErrorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
 //#endregion
 //#region src/gitignore.ts
-var muonGitignoreEntry = ".muon/";
+var muonGitignoreEntries = [
+	".muon/",
+	"dist-muon-*/",
+	"artifacts/"
+];
+var muonGitignoreEntryAliases = {
+	".muon/": [
+		".muon/",
+		"/.muon/",
+		".muon",
+		"/.muon"
+	],
+	"dist-muon-*/": [
+		"dist-muon-*/",
+		"/dist-muon-*/",
+		"dist-muon-*",
+		"/dist-muon-*"
+	],
+	"artifacts/": [
+		"artifacts/",
+		"/artifacts/",
+		"artifacts",
+		"/artifacts"
+	]
+};
 var isMissingFileError = (error) => error instanceof Error && error.code === "ENOENT";
-var hasMuonGitignoreEntry = (content) => content.split(/\r?\n/).map((line) => line.trim()).some((line) => line === muonGitignoreEntry || line === `/${muonGitignoreEntry}` || line === ".muon" || line === "/.muon");
+var hasMuonGitignoreEntry = (content, entry) => content.split(/\r?\n/).map((line) => line.trim()).some((line) => muonGitignoreEntryAliases[entry].includes(line));
 /**
-* Adds the Muon staging directory to a project .gitignore file.
+* Adds Muon generated directories to a project .gitignore file.
 *
 * @param root Project root containing the .gitignore file.
 * @returns Gitignore update result.
@@ -2103,12 +2181,13 @@ var ensureMuonGitignoreEntry = async (root) => {
 	} catch (error) {
 		if (!isMissingFileError(error)) throw error;
 	}
-	if (hasMuonGitignoreEntry(content)) return {
+	const missingEntries = muonGitignoreEntries.filter((entry) => !hasMuonGitignoreEntry(content, entry));
+	if (missingEntries.length === 0) return {
 		gitignorePath,
 		changed: false
 	};
 	const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-	await writeFile(gitignorePath, `${content}${separator}${muonGitignoreEntry}\n`);
+	await writeFile(gitignorePath, `${content}${separator}${missingEntries.join("\n")}\n`);
 	return {
 		gitignorePath,
 		changed: true
@@ -2377,6 +2456,7 @@ var attachMuonVitePluginOptions = (plugin, options) => {
 };
 //#endregion
 //#region src/vite.ts
+var suppressViteMuonBuildEnvironmentKey = "MUON_SUPPRESS_VITE_MUON_BUILD";
 /**
 * Creates a Vite plugin that launches Muon during Vite dev startup.
 *
@@ -2387,6 +2467,10 @@ var muon = (options = {}) => {
 	let resolvedConfig = void 0;
 	return attachMuonVitePluginOptions({
 		name: "muon",
+		config: (config) => {
+			if (config.server?.watch === null) return null;
+			return { server: { watch: createMuonWatchOptions(config.server?.watch) } };
+		},
 		configResolved: (config) => {
 			resolvedConfig = config;
 		},
@@ -2401,12 +2485,26 @@ var muon = (options = {}) => {
 		},
 		closeBundle: async () => {
 			if (resolvedConfig === void 0 || resolvedConfig.command !== "build") return;
+			if (process.env[suppressViteMuonBuildEnvironmentKey] === "1") return;
 			if (options.build === false) return;
 			const buildOptions = typeof options.build === "object" ? options.build : {};
 			await buildMuonApp(createMuonBuildOptions(resolvedConfig, buildOptions));
 		}
 	}, options);
 };
+var isMuonStagingWatchPath = (path) => {
+	const normalized = path.replaceAll("\\", "/");
+	return normalized === ".muon" || normalized.startsWith(".muon/") || normalized.endsWith("/.muon") || normalized.includes("/.muon/");
+};
+var mergeMuonWatchIgnored = (ignored) => {
+	const muonIgnored = (path) => isMuonStagingWatchPath(path);
+	if (ignored === void 0) return muonIgnored;
+	return Array.isArray(ignored) ? [...ignored, muonIgnored] : [ignored, muonIgnored];
+};
+var createMuonWatchOptions = (watch) => ({
+	...watch ?? {},
+	ignored: mergeMuonWatchIgnored(watch?.ignored)
+});
 var createMuonBuildOptions = (config, buildOptions) => {
 	const outDir = isAbsolute(config.build.outDir) ? config.build.outDir : resolve(config.root, config.build.outDir);
 	const options = {
@@ -2417,6 +2515,7 @@ var createMuonBuildOptions = (config, buildOptions) => {
 	if (buildOptions.allTargets !== void 0) options.allTargets = buildOptions.allTargets;
 	if (buildOptions.targets !== void 0) options.targets = buildOptions.targets;
 	if (buildOptions.appName !== void 0) options.appName = buildOptions.appName;
+	if (buildOptions.appId !== void 0) options.appId = buildOptions.appId;
 	if (buildOptions.outputRoot !== void 0) options.outputRoot = buildOptions.outputRoot;
 	if (buildOptions.configPath !== void 0) options.configPath = buildOptions.configPath;
 	if (buildOptions.packageDirectory !== void 0) options.packageDirectory = buildOptions.packageDirectory;