use crate::analysis::{compute_diff, DiffStatus, RetainedSizeAnalyzer};
use crate::parser::parse_wasm;
use anyhow::{Context, Result};
use colored::Colorize;
use humansize::{format_size, BINARY};
use std::path::Path;
pub fn run(old_path: &Path, new_path: &Path, limit: usize, json: bool) -> Result<()> {
let old_parsed = parse_wasm(old_path).context("Failed to parse old WASM file")?;
let new_parsed = parse_wasm(new_path).context("Failed to parse new WASM file")?;
let old_analyzer = RetainedSizeAnalyzer::new(old_parsed);
let new_analyzer = RetainedSizeAnalyzer::new(new_parsed);
let old_analysis = old_analyzer.analyze(false);
let new_analysis = new_analyzer.analyze(false);
let diff = compute_diff(&old_analysis, &new_analysis);
if json {
output_json(&diff, limit)?;
} else {
output_human(&diff, limit, old_path, new_path)?;
}
Ok(())
}
fn output_json(diff: &crate::analysis::DiffResult, limit: usize) -> Result<()> {
#[derive(serde::Serialize)]
struct JsonOutput {
old_total: u64,
new_total: u64,
size_delta: i64,
items: Vec<crate::analysis::DiffItem>,
}
let items: Vec<_> = diff
.items
.iter()
.filter(|item| !matches!(item.status, DiffStatus::Unchanged))
.take(limit)
.cloned()
.collect();
let output = JsonOutput {
old_total: diff.old_total,
new_total: diff.new_total,
size_delta: diff.size_delta,
items,
};
println!("{}", serde_json::to_string_pretty(&output)?);
Ok(())
}
fn output_human(
diff: &crate::analysis::DiffResult,
limit: usize,
old_path: &Path,
new_path: &Path,
) -> Result<()> {
println!();
println!("{}", " WASM Size Diff ".bold().white().on_blue());
println!();
println!(
" {} {} ({})",
"Old:".dimmed(),
old_path.file_name().unwrap_or_default().to_string_lossy(),
format_size(diff.old_total, BINARY)
);
println!(
" {} {} ({})",
"New:".dimmed(),
new_path.file_name().unwrap_or_default().to_string_lossy(),
format_size(diff.new_total, BINARY)
);
println!();
let delta_str = format_delta(diff.size_delta);
let delta_pct = if diff.old_total > 0 {
(diff.size_delta as f64 / diff.old_total as f64) * 100.0
} else {
0.0
};
let total_line = format!(
"Total: {} -> {} ({} / {:+.1}%)",
format_size(diff.old_total, BINARY),
format_size(diff.new_total, BINARY),
delta_str,
delta_pct
);
match diff.size_delta.cmp(&0) {
std::cmp::Ordering::Greater => println!(" {}", total_line.red()),
std::cmp::Ordering::Less => println!(" {}", total_line.green()),
std::cmp::Ordering::Equal => println!(" {}", total_line),
}
println!();
let changed: Vec<_> = diff
.items
.iter()
.filter(|item| !matches!(item.status, DiffStatus::Unchanged))
.take(limit)
.collect();
if changed.is_empty() {
println!(" {}", "No changes detected.".dimmed());
return Ok(());
}
println!("{}", "Changes:".bold());
let added: Vec<_> = changed
.iter()
.filter(|i| matches!(i.status, DiffStatus::Added))
.collect();
let removed: Vec<_> = changed
.iter()
.filter(|i| matches!(i.status, DiffStatus::Removed))
.collect();
let modified: Vec<_> = changed
.iter()
.filter(|i| matches!(i.status, DiffStatus::Changed))
.collect();
if !added.is_empty() {
println!("\n {} ({}):", "Added".green().bold(), added.len());
for item in added.iter().take(limit / 3 + 1) {
let name = truncate_name(&item.name, 50);
println!(
" {} {:>10} [{}] {}",
"+".green(),
format_size(item.new_size, BINARY).green(),
item.kind,
name
);
}
}
if !removed.is_empty() {
println!("\n {} ({}):", "Removed".red().bold(), removed.len());
for item in removed.iter().take(limit / 3 + 1) {
let name = truncate_name(&item.name, 50);
println!(
" {} {:>10} [{}] {}",
"-".red(),
format_size(item.old_size, BINARY).red(),
item.kind,
name
);
}
}
if !modified.is_empty() {
let mut modified: Vec<_> = modified.into_iter().collect();
modified.sort_by_key(|b| std::cmp::Reverse(b.delta.abs()));
println!("\n {} ({}):", "Changed".yellow().bold(), modified.len());
for item in modified.iter().take(limit / 3 + 1) {
let name = truncate_name(&item.name, 50);
let delta = format_delta(item.delta);
let arrow = if item.delta > 0 {
"↑".red()
} else {
"↓".green()
};
println!(" {} {:>10} [{}] {}", arrow, delta, item.kind, name);
}
}
println!();
Ok(())
}
fn format_delta(delta: i64) -> String {
if delta >= 0 {
format!("+{}", format_size(delta as u64, BINARY))
} else {
format!("-{}", format_size((-delta) as u64, BINARY))
}
}
fn truncate_name(name: &str, max_len: usize) -> String {
if name.len() > max_len {
format!("{}...", &name[..max_len - 3])
} else {
name.to_string()
}
}