vize 0.65.0 → 0.66.0

package/README.md

@@ -3,12 +3,16 @@
 The `vize` npm package provides:
 
 - shared config utilities (`defineConfig`, `loadConfig`)
+- the native `vize build` command
+- the native `vize fmt` command
 - the native `vize lint` command
 - the native `vize check` command for package scripts
+- `vize ready` for `fmt --write -> lint -> check -> build`
+- `vize upgrade` for updating the npm package
 
 For Vite integration, pair it with `@vizejs/vite-plugin`.
-For the full Rust-native CLI (`build`, `fmt`, project-backed `check`, `lsp`, `ide`), install the
-Rust `vize` binary with `cargo install vize`.
+For the full Rust-native CLI (`lsp`, `ide`, project-backed `check`, and `check-server`), install
+the Rust `vize` binary with `cargo install vize`.
 
 Need `vp` first? Install Vite+ once from the [Vite+ install guide](https://viteplus.dev/guide/install).
 
@@ -20,13 +24,15 @@ vp install -D vize
 
 ## CLI
 
-The npm CLI exposes `lint` and `check`:
+The npm CLI exposes the common package-script commands:
 
 ```bash
+vp exec vize build src
+vp exec vize fmt --write src
 vp exec vize lint src
-vp exec vize lint --preset opinionated --help-level short src
 vp exec vize check
-vp exec vize check src
+vp exec vize ready src
+vp exec vize upgrade
 ```
 
 Shared config discovery is supported for the npm CLI:
@@ -56,6 +62,8 @@ Override config discovery with `--config`, or disable it with `--no-config`.
 scripts after installing `vize`. Use the Rust CLI when you need Corsa project diagnostics across
 Vue, TS, TSX, and `.d.ts` inputs.
 
+`vize ready` runs `fmt --write`, `lint`, `check`, and `build` in that order.
+
 ## Programmatic Config Helpers
 
 ```ts

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 import { loadConfig } from "./config.mjs";
 import { createRequire } from "node:module";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import { spawnSync } from "node:child_process";
 import { pathToFileURL } from "node:url";
@@ -37,12 +37,19 @@ function getBindingPackageName() {
 		default: throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
 	}
 }
+const REQUIRED_BINDINGS = {
+	build: "compileSfcBatchWithResults",
+	check: "typeCheck",
+	fmt: "formatSfc",
+	lint: "lint"
+};
 function loadNative(command) {
 	const attemptedPackages = getAttemptedPackages();
 	let lastError = null;
+	const requiredBinding = REQUIRED_BINDINGS[command];
 	for (const packageName of attemptedPackages) try {
 		const binding = require(packageName);
-		if (typeof binding[command === "check" ? "typeCheck" : "lint"] !== "function") throw new Error(`${packageName} does not expose the ${command} binding.`);
+		if (typeof binding[requiredBinding] !== "function") throw new Error(`${packageName} does not expose the ${command} binding.`);
 		return binding;
 	} catch (error) {
 		lastError = error;
@@ -71,7 +78,27 @@ function shouldPreferWorkspaceBinding(resolvedPath) {
 }
 function printUsage() {
 	console.error("Usage: vize <command> [options]");
-	console.error("Commands: check, lint, musea");
+	console.error("Commands: build, fmt, check, lint, upgrade, ready, musea");
+}
+function printBuildUsage() {
+	console.error("Usage: vize build [options] [files-or-directories]");
+	console.error("Options:");
+	console.error("  -o, --output <dir>             Output directory");
+	console.error("  -f, --format <js|json|stats>   Output format");
+	console.error("      --ssr                      Enable SSR compilation");
+	console.error("      --script-ext <mode>        preserve or downcompile");
+	console.error("  -j, --threads <number>         Worker thread count");
+}
+function printFmtUsage() {
+	console.error("Usage: vize fmt [options] [files-or-directories]");
+	console.error("Options:");
+	console.error("      --check                    Exit with an error if files need formatting");
+	console.error("  -w, --write                    Write formatted output");
+	console.error("      --single-quote             Use single quotes");
+	console.error("      --print-width <number>     Maximum line width");
+	console.error("      --tab-width <number>       Indentation width");
+	console.error("      --use-tabs                 Indent with tabs");
+	console.error("      --no-semi                  Omit semicolons");
 }
 function printCheckUsage() {
 	console.error("Usage: vize check [options] [files-or-directories]");
@@ -86,6 +113,21 @@ function printCheckUsage() {
 	console.error("");
 	console.error("Note: npm `vize check` uses the packaged NAPI checker. Install the Rust CLI for project-backed Corsa diagnostics.");
 }
+function printUpgradeUsage() {
+	console.error("Usage: vize upgrade [options]");
+	console.error("Options:");
+	console.error("      --package-manager <name>   npm, pnpm, yarn, bun, or vp");
+	console.error("  -g, --global                   Upgrade the global installation");
+	console.error("      --dry-run                  Print the command without running it");
+}
+function printReadyUsage() {
+	console.error("Usage: vize ready [options] [files-or-directories]");
+	console.error("Runs: fmt --write -> lint -> check -> build");
+	console.error("Options:");
+	console.error("  -o, --output <dir>             Output directory for build");
+	console.error("      --ssr                      Enable SSR compilation for build");
+	console.error("      --script-ext <mode>        preserve or downcompile");
+}
 function resolvePackageBinaryFromCwd(packageName, binName = packageName) {
 	const packageJsonPath = createRequire(pathToFileURL(path.join(process.cwd(), "package.json")).href).resolve(`${packageName}/package.json`);
 	const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
@@ -140,6 +182,214 @@ function parseLintCommand(args) {
 		sharedConfig
 	};
 }
+function parseBuildCommand(args) {
+	const patterns = [];
+	const options = {
+		output: "./dist",
+		format: "js",
+		scriptExt: "downcompile"
+	};
+	const sharedConfig = { configMode: "root" };
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--output" || arg === "-o") options.output = args[++i] ?? options.output;
+		else if (arg === "--format" || arg === "-f") {
+			const format = args[++i];
+			if (format === "js" || format === "json" || format === "stats") options.format = format;
+		} else if (arg === "--ssr") options.ssr = true;
+		else if (arg === "--vapor") options.vapor = true;
+		else if (arg === "--custom-renderer") options.customRenderer = true;
+		else if (arg === "--script-ext") {
+			const scriptExt = args[++i];
+			if (scriptExt === "preserve" || scriptExt === "downcompile") options.scriptExt = scriptExt;
+		} else if (arg === "--threads" || arg === "-j") options.threads = Number.parseInt(args[++i], 10);
+		else if (arg === "--config" || arg === "-c") {
+			const configFile = args[++i];
+			if (!configFile) throw new Error("Missing path after --config");
+			sharedConfig.configFile = configFile;
+		} else if (arg === "--no-config") sharedConfig.configMode = "none";
+		else if (arg === "--profile" || arg === "--continue-on-error") {} else if (arg === "--help" || arg === "-h") options.help = true;
+		else if (!arg.startsWith("-")) patterns.push(arg);
+	}
+	return {
+		patterns,
+		options,
+		sharedConfig
+	};
+}
+function getScriptLang(source) {
+	return source.match(/<script\b[^>]*\blang=["']([^"']+)["']/i)?.[1] ?? "js";
+}
+function getOutputExtension(source, scriptExt) {
+	if (scriptExt === "downcompile") return "js";
+	const lang = getScriptLang(source);
+	return lang === "ts" || lang === "tsx" || lang === "jsx" ? lang : "js";
+}
+function outputFileName(file, extension) {
+	return path.basename(file).replace(/\.vue$/i, `.${extension}`);
+}
+function toNativeBuildOptions(options) {
+	const isTs = options.scriptExt === "preserve";
+	return {
+		ssr: options.ssr,
+		vapor: options.vapor,
+		customRenderer: options.customRenderer,
+		custom_renderer: options.customRenderer,
+		isTs,
+		is_ts: isTs,
+		threads: options.threads
+	};
+}
+async function runBuild(args) {
+	const { patterns, options, sharedConfig } = parseBuildCommand(args);
+	if (options.help) {
+		printBuildUsage();
+		return;
+	}
+	const config = await loadConfig(process.cwd(), {
+		mode: sharedConfig.configMode,
+		configFile: sharedConfig.configFile,
+		env: {
+			mode: process.env.NODE_ENV ?? "development",
+			command: "build"
+		}
+	});
+	if (sharedConfig.configFile && !config) throw new Error(`Could not find config file: ${sharedConfig.configFile}`);
+	options.ssr ??= config?.compiler?.ssr;
+	options.vapor ??= config?.compiler?.vapor;
+	options.customRenderer ??= config?.compiler?.customRenderer;
+	if (config?.compiler?.scriptExt === "ts") options.scriptExt = "preserve";
+	else if (config?.compiler?.scriptExt === "js") options.scriptExt = "downcompile";
+	const files = collectVueFiles(patterns);
+	if (files.length === 0) {
+		process.stderr.write(`No Vue files found matching inputs: ${JSON.stringify(patterns)}\n`);
+		process.exit(1);
+	}
+	const inputs = files.map((file) => ({
+		path: file,
+		source: readFileSync(file, "utf8")
+	}));
+	const native = loadNative("build");
+	const startedAt = performance.now();
+	const result = native.compileSfcBatchWithResults(inputs, toNativeBuildOptions(options));
+	const timeMs = result.timeMs ?? result.time_ms ?? performance.now() - startedAt;
+	const results = [...result.results].sort((left, right) => left.path.localeCompare(right.path));
+	if (options.format !== "stats") mkdirSync(options.output, { recursive: true });
+	for (const fileResult of results) {
+		const source = inputs.find((input) => input.path === fileResult.path)?.source ?? "";
+		for (const warning of fileResult.warnings) process.stderr.write(`warning: ${displayPath(fileResult.path)} ${warning}\n`);
+		for (const error of fileResult.errors) process.stderr.write(`error: ${displayPath(fileResult.path)} ${error}\n`);
+		if (fileResult.errors.length > 0 || options.format === "stats") continue;
+		const extension = options.format === "json" ? "json" : getOutputExtension(source, options.scriptExt);
+		writeFileSync(path.join(options.output, outputFileName(fileResult.path, extension)), options.format === "json" ? JSON.stringify(fileResult, null, 2) : fileResult.code);
+	}
+	const failed = result.failedCount ?? result.failed_count ?? results.filter((r) => r.errors.length).length;
+	const success = result.successCount ?? result.success_count ?? results.length - failed;
+	process.stderr.write(`\x1b[32mOK\x1b[0m Built ${success} Vue file(s) in ${timeMs.toFixed(2)}ms\n`);
+	if (failed > 0) {
+		process.stderr.write(`\x1b[31mERR\x1b[0m ${failed} file(s) failed\n`);
+		process.exit(1);
+	}
+}
+function parseFmtCommand(args) {
+	const patterns = [];
+	const options = {};
+	const sharedConfig = { configMode: "root" };
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--check") options.check = true;
+		else if (arg === "--write" || arg === "-w") options.write = true;
+		else if (arg === "--single-quote") options.singleQuote = true;
+		else if (arg === "--print-width") options.printWidth = Number.parseInt(args[++i], 10);
+		else if (arg === "--tab-width") options.tabWidth = Number.parseInt(args[++i], 10);
+		else if (arg === "--use-tabs") options.useTabs = true;
+		else if (arg === "--no-semi") options.semi = false;
+		else if (arg === "--sort-attributes") options.sortAttributes = true;
+		else if (arg === "--single-attribute-per-line") options.singleAttributePerLine = true;
+		else if (arg === "--max-attributes-per-line") options.maxAttributesPerLine = Number.parseInt(args[++i], 10);
+		else if (arg === "--normalize-directive-shorthands") options.normalizeDirectiveShorthands = true;
+		else if (arg === "--config" || arg === "-c") {
+			const configFile = args[++i];
+			if (!configFile) throw new Error("Missing path after --config");
+			sharedConfig.configFile = configFile;
+		} else if (arg === "--no-config") sharedConfig.configMode = "none";
+		else if (arg === "--profile") {} else if (arg === "--help" || arg === "-h") options.help = true;
+		else if (!arg.startsWith("-")) patterns.push(arg);
+	}
+	return {
+		patterns,
+		options,
+		sharedConfig
+	};
+}
+function toNativeFormatOptions(options) {
+	return {
+		printWidth: options.printWidth,
+		print_width: options.printWidth,
+		tabWidth: options.tabWidth,
+		tab_width: options.tabWidth,
+		useTabs: options.useTabs,
+		use_tabs: options.useTabs,
+		semi: options.semi,
+		singleQuote: options.singleQuote,
+		single_quote: options.singleQuote,
+		sortAttributes: options.sortAttributes,
+		sort_attributes: options.sortAttributes,
+		singleAttributePerLine: options.singleAttributePerLine,
+		single_attribute_per_line: options.singleAttributePerLine,
+		maxAttributesPerLine: options.maxAttributesPerLine,
+		max_attributes_per_line: options.maxAttributesPerLine,
+		normalizeDirectiveShorthands: options.normalizeDirectiveShorthands,
+		normalize_directive_shorthands: options.normalizeDirectiveShorthands
+	};
+}
+async function runFmt(args) {
+	const { patterns, options, sharedConfig } = parseFmtCommand(args);
+	if (options.help) {
+		printFmtUsage();
+		return;
+	}
+	const config = await loadConfig(process.cwd(), {
+		mode: sharedConfig.configMode,
+		configFile: sharedConfig.configFile,
+		env: {
+			mode: process.env.NODE_ENV ?? "development",
+			command: "fmt"
+		}
+	});
+	if (sharedConfig.configFile && !config) throw new Error(`Could not find config file: ${sharedConfig.configFile}`);
+	options.printWidth ??= config?.formatter?.printWidth;
+	options.tabWidth ??= config?.formatter?.tabWidth;
+	options.useTabs ??= config?.formatter?.useTabs;
+	options.semi ??= config?.formatter?.semi;
+	options.singleQuote ??= config?.formatter?.singleQuote;
+	const files = collectVueFiles(patterns);
+	if (files.length === 0) {
+		process.stderr.write(`No Vue files found matching inputs: ${JSON.stringify(patterns)}\n`);
+		return;
+	}
+	const native = loadNative("fmt");
+	let changed = 0;
+	let errored = 0;
+	for (const file of files) {
+		const source = readFileSync(file, "utf8");
+		try {
+			const result = native.formatSfc(source, toNativeFormatOptions(options));
+			if (!result.changed) continue;
+			changed++;
+			if (options.check) process.stderr.write(`Would reformat: ${displayPath(file)}\n`);
+			else if (options.write) {
+				writeFileSync(file, result.code);
+				process.stderr.write(`Reformatted: ${displayPath(file)}\n`);
+			} else process.stderr.write(`Would reformat: ${displayPath(file)}\n`);
+		} catch (error) {
+			errored++;
+			process.stderr.write(`Error formatting ${displayPath(file)}: ${error instanceof Error ? error.message : String(error)}\n`);
+		}
+	}
+	process.stderr.write(`\x1b[32mOK\x1b[0m Formatted ${files.length} Vue file(s), ${changed} changed\n`);
+	if (errored > 0 || options.check && changed > 0) process.exit(1);
+}
 function parseCheckCommand(args) {
 	const patterns = [];
 	const options = {};
@@ -246,7 +496,7 @@ function collectVueFilesFromGlob(pattern) {
 		return regex.test(comparable);
 	});
 }
-function collectCheckFiles(patterns) {
+function collectVueFiles(patterns) {
 	const files = /* @__PURE__ */ new Set();
 	const inputs = patterns.length === 0 ? ["."] : patterns;
 	for (const input of inputs) {
@@ -350,7 +600,7 @@ async function runCheck(args) {
 	options.checkProps ??= config?.typeChecker?.checkProps;
 	options.checkEmits ??= config?.typeChecker?.checkEmits;
 	options.checkTemplateBindings ??= config?.typeChecker?.checkTemplateBindings;
-	const files = collectCheckFiles(patterns);
+	const files = collectVueFiles(patterns);
 	if (files.length === 0) {
 		process.stderr.write(`No Vue files found matching inputs: ${JSON.stringify(patterns)}\n`);
 		return;
@@ -421,8 +671,158 @@ async function runLint(args) {
 		process.exit(1);
 	}
 }
-const NAPI_COMMANDS = new Set(["check", "lint"]);
-const JS_COMMANDS = new Set(["musea"]);
+function parseUpgradeCommand(args) {
+	const options = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--package-manager") {
+			const packageManager = args[++i];
+			if (packageManager === "bun" || packageManager === "npm" || packageManager === "pnpm" || packageManager === "vp" || packageManager === "yarn") options.packageManager = packageManager;
+		} else if (arg === "--global" || arg === "-g") options.global = true;
+		else if (arg === "--dry-run") options.dryRun = true;
+		else if (arg === "--help" || arg === "-h") options.help = true;
+	}
+	return options;
+}
+function readCwdPackageJson() {
+	const packageJsonPath = path.join(process.cwd(), "package.json");
+	if (!existsSync(packageJsonPath)) return null;
+	return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+}
+function detectPackageManager(explicit) {
+	if (explicit) return explicit;
+	const userAgent = process.env.npm_config_user_agent ?? "";
+	if (userAgent.startsWith("pnpm")) return "pnpm";
+	if (userAgent.startsWith("yarn")) return "yarn";
+	if (userAgent.startsWith("bun")) return "bun";
+	if (userAgent.startsWith("npm")) return "npm";
+	const packageManager = readCwdPackageJson()?.packageManager;
+	if (packageManager?.startsWith("pnpm")) return "pnpm";
+	if (packageManager?.startsWith("yarn")) return "yarn";
+	if (packageManager?.startsWith("bun")) return "bun";
+	return "npm";
+}
+function buildUpgradeCommand(packageManager, options) {
+	const saveDev = !readCwdPackageJson()?.dependencies?.vize;
+	const packageSpec = "vize@latest";
+	if (packageManager === "vp") return {
+		command: "vp",
+		args: [
+			"install",
+			...options.global ? ["-g"] : saveDev ? ["-D"] : [],
+			packageSpec
+		]
+	};
+	if (packageManager === "pnpm") return {
+		command: "pnpm",
+		args: [
+			"add",
+			...options.global ? ["-g"] : saveDev ? ["-D"] : [],
+			packageSpec
+		]
+	};
+	if (packageManager === "yarn") return {
+		command: "yarn",
+		args: options.global ? [
+			"global",
+			"add",
+			packageSpec
+		] : [
+			"add",
+			...saveDev ? ["-D"] : [],
+			packageSpec
+		]
+	};
+	if (packageManager === "bun") return {
+		command: "bun",
+		args: [
+			"add",
+			...options.global ? ["-g"] : saveDev ? ["-d"] : [],
+			packageSpec
+		]
+	};
+	return {
+		command: "npm",
+		args: [
+			"install",
+			...options.global ? ["-g"] : saveDev ? ["-D"] : [],
+			packageSpec
+		]
+	};
+}
+function runUpgrade(args) {
+	const options = parseUpgradeCommand(args);
+	if (options.help) {
+		printUpgradeUsage();
+		return;
+	}
+	const command = buildUpgradeCommand(detectPackageManager(options.packageManager), options);
+	if (options.dryRun) {
+		process.stdout.write(`${command.command} ${command.args.join(" ")}\n`);
+		return;
+	}
+	const result = spawnSync(command.command, command.args, {
+		stdio: "inherit",
+		cwd: process.cwd(),
+		env: process.env
+	});
+	if (result.error) throw result.error;
+	process.exit(result.status ?? 1);
+}
+function parseReadyCommand(args) {
+	const patterns = [];
+	const options = {
+		output: "./dist",
+		scriptExt: "downcompile"
+	};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--output" || arg === "-o") options.output = args[++i] ?? options.output;
+		else if (arg === "--ssr") options.ssr = true;
+		else if (arg === "--script-ext") {
+			const scriptExt = args[++i];
+			if (scriptExt === "preserve" || scriptExt === "downcompile") options.scriptExt = scriptExt;
+		} else if (arg === "--help" || arg === "-h") options.help = true;
+		else if (!arg.startsWith("-")) patterns.push(arg);
+	}
+	return {
+		patterns,
+		options
+	};
+}
+async function runReady(args) {
+	const { patterns, options } = parseReadyCommand(args);
+	if (options.help) {
+		printReadyUsage();
+		return;
+	}
+	process.stderr.write("vize ready: fmt\n");
+	await runFmt(["--write", ...patterns]);
+	process.stderr.write("vize ready: lint\n");
+	await runLint(patterns);
+	process.stderr.write("vize ready: check\n");
+	await runCheck(patterns);
+	process.stderr.write("vize ready: build\n");
+	await runBuild([
+		"--output",
+		options.output,
+		"--script-ext",
+		options.scriptExt,
+		...options.ssr ? ["--ssr"] : [],
+		...patterns
+	]);
+}
+const NAPI_COMMANDS = new Set([
+	"build",
+	"check",
+	"fmt",
+	"lint"
+]);
+const JS_COMMANDS = new Set([
+	"musea",
+	"ready",
+	"upgrade"
+]);
 async function main() {
 	const args = process.argv.slice(2);
 	const command = args[0];
@@ -433,9 +833,15 @@ async function main() {
 	if (NAPI_COMMANDS.has(command)) {
 		const commandArgs = args.slice(1);
 		switch (command) {
+			case "build":
+				await runBuild(commandArgs);
+				break;
 			case "check":
 				await runCheck(commandArgs);
 				break;
+			case "fmt":
+				await runFmt(commandArgs);
+				break;
 			case "lint":
 				await runLint(commandArgs);
 				break;
@@ -446,6 +852,12 @@ async function main() {
 			case "musea":
 				runMusea(commandArgs);
 				break;
+			case "ready":
+				await runReady(commandArgs);
+				break;
+			case "upgrade":
+				runUpgrade(commandArgs);
+				break;
 		}
 	} else {
 		printUsage();