use crate::core::model::{Edit, Span, UdError};
use jsonc_parser::ast::{ObjectPropName, Value};
use jsonc_parser::{CollectOptions, ParseOptions, parse_to_ast};
pub struct FoundJsonProp {
pub section: String,
pub name: String,
pub val: String,
pub val_start: usize,
pub val_end: usize,
}
pub fn walk_json_section(raw: &str, sections: &[&str]) -> Result<Vec<FoundJsonProp>, UdError> {
let collect_opts = CollectOptions::default();
let parse_opts = ParseOptions::default();
let parse_res = parse_to_ast(raw, &collect_opts, &parse_opts)
.map_err(|e| UdError::Parse(format!("Failed to parse JSON: {}", e)))?;
let mut found = Vec::new();
if let Some(Value::Object(root_obj)) = parse_res.value {
for prop in &root_obj.properties {
let prop_name = match &prop.name {
ObjectPropName::String(s) => s.value.as_ref(),
ObjectPropName::Word(w) => w.value,
};
if sections.contains(&prop_name) {
if let Value::Object(section_obj) = &prop.value {
for sub_prop in §ion_obj.properties {
let sub_name = match &sub_prop.name {
ObjectPropName::String(s) => s.value.to_string(),
ObjectPropName::Word(w) => w.value.to_string(),
};
if let Value::StringLit(str_lit) = &sub_prop.value {
found.push(FoundJsonProp {
section: prop_name.to_string(),
name: sub_name,
val: str_lit.value.to_string(),
val_start: str_lit.range.start,
val_end: str_lit.range.end,
});
}
}
}
}
}
}
Ok(found)
}
pub fn compute_span(body: &str, start: usize, end: usize) -> Span {
if body.starts_with("npm:") || body.starts_with("jsr:") {
if let Some(last_at_idx) = body
.char_indices()
.filter(|&(idx, c)| idx >= 1 && c == '@')
.map(|(idx, _)| idx)
.last()
{
let version_part = &body[last_at_idx + 1..];
let sub_path_len = version_part.find('/').unwrap_or(version_part.len());
let constraint_start = start + 1 + last_at_idx + 1;
let constraint_end = constraint_start + sub_path_len;
Span {
start: constraint_start,
end: constraint_end,
}
} else {
Span {
start: start + 1,
end: end - 1,
}
}
} else {
Span {
start: start + 1,
end: end - 1,
}
}
}
pub fn write_batch_json(raw: &str, edits: &[Edit]) -> Result<String, UdError> {
let mut sorted_edits: Vec<&Edit> = edits.iter().collect();
sorted_edits.sort_by(|a, b| {
let a_start = a.dep.span.map(|s| s.start).unwrap_or(0);
let b_start = b.dep.span.map(|s| s.start).unwrap_or(0);
b_start.cmp(&a_start)
});
let mut content = raw.to_string();
for edit in sorted_edits {
if let Some(span) = edit.dep.span {
if span.start <= span.end && span.end <= content.len() {
let existing = &content[span.start..span.end];
if existing != edit.dep.constraint.0 {
return Err(UdError::Parse(format!(
"Safety check failed: existing content '{}' does not match expected constraint '{}' at {:?}",
existing, edit.dep.constraint.0, span
)));
}
content.replace_range(span.start..span.end, &edit.replacement.0);
} else {
return Err(UdError::Parse(format!("Invalid span range: {:?}", span)));
}
}
}
Ok(content)
}