hsml/

lib.rs

pub mod common;
pub mod compiler;
pub mod converter;
pub mod diagnostic;
pub mod formatter;
pub mod parser;
pub mod validate;

use serde::Serialize;
use wasm_bindgen::prelude::*;

/// Parse HSML source and return the AST, or an error string on failure.
fn parse_source(source: &str) -> Result<parser::RootNode, String> {
    let span = parser::Span::new(source);
    let (rest, ast) = parser::parse::parse(span).map_err(|e| format!("HSML parse error: {e}"))?;

    if !rest.fragment().is_empty() {
        return Err(format!(
            "HSML parse error: unconsumed input at line {}, column {}",
            rest.location_line(),
            rest.get_column()
        ));
    }

    Ok(ast)
}

/// Core compile logic shared by WASM and native callers.
pub fn compile_content_core(source: &str) -> Result<String, String> {
    let ast = parse_source(source)?;
    compiler::compile(&ast, &compiler::HsmlCompileOptions::default())
}

/// Result of compiling HSML source with diagnostic support.
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct CompileOutput {
    /// The compiled HTML output.
    pub html: String,
    /// Warnings and other non-fatal diagnostics collected during validation.
    pub diagnostics: Vec<diagnostic::Diagnostic>,
}

/// Check HSML source for errors and warnings without compiling.
/// Returns all diagnostics (both parse errors and validation warnings).
pub fn check_content(source: &str) -> Vec<diagnostic::Diagnostic> {
    let span = parser::Span::new(source);

    let (rest, ast) = match parser::parse::parse(span) {
        Ok(result) => result,
        Err(e) => return vec![diagnostic::Diagnostic::from(&e)],
    };

    if !rest.fragment().is_empty() {
        return vec![diagnostic::Diagnostic {
            severity: diagnostic::Severity::Error,
            message: "Unconsumed input".to_string(),
            code: None,
            location: Some(diagnostic::Location {
                start: diagnostic::Position {
                    line: rest.location_line(),
                    column: rest.get_column() as u32,
                },
                end: diagnostic::Position {
                    line: rest.location_line(),
                    column: rest.get_column() as u32,
                },
            }),
            file_path: None,
        }];
    }

    validate::validate(&ast, source)
}

/// Compile HSML source, returning structured diagnostics on error.
/// On success, returns the HTML output along with any warnings.
pub fn compile_content_diagnostics(
    source: &str,
) -> Result<CompileOutput, Vec<diagnostic::Diagnostic>> {
    compile_content_diagnostics_with_options(source, &compiler::HsmlCompileOptions::default())
}

/// Compile HSML source with custom options, returning structured diagnostics on error.
pub fn compile_content_diagnostics_with_options(
    source: &str,
    options: &compiler::HsmlCompileOptions,
) -> Result<CompileOutput, Vec<diagnostic::Diagnostic>> {
    let span = parser::Span::new(source);

    let (rest, ast) =
        parser::parse::parse(span).map_err(|e| vec![diagnostic::Diagnostic::from(&e)])?;

    if !rest.fragment().is_empty() {
        return Err(vec![diagnostic::Diagnostic {
            severity: diagnostic::Severity::Error,
            message: "Unconsumed input".to_string(),
            code: None,
            location: Some(diagnostic::Location {
                start: diagnostic::Position {
                    line: rest.location_line(),
                    column: rest.get_column() as u32,
                },
                end: diagnostic::Position {
                    line: rest.location_line(),
                    column: rest.get_column() as u32,
                },
            }),
            file_path: None,
        }]);
    }

    // Run validation to collect warnings
    let diagnostics = validate::validate(&ast, source);

    let html = compiler::compile(&ast, options)
        .map_err(|e| vec![diagnostic::Diagnostic::compiler_error(e)])?;

    Ok(CompileOutput { html, diagnostics })
}

/// Core convert logic shared by WASM and native callers.
pub fn convert_html_core(html: &str) -> Result<String, String> {
    converter::convert(html)
}

/// Core format logic shared by WASM and native callers.
pub fn format_content_core(
    source: &str,
    options: &formatter::FormatOptions,
) -> Result<String, String> {
    let ast = parse_source(source)?;
    Ok(formatter::format(&ast, options))
}

/// WASM format options that deserializes from a JS object.
#[derive(serde::Deserialize)]
#[serde(rename_all = "camelCase")]
struct WasmFormatOptions {
    #[serde(default = "default_indent_size")]
    indent_size: usize,
    #[serde(default = "default_print_width")]
    print_width: usize,
}

fn default_indent_size() -> usize {
    formatter::FormatOptions::default().indent_size
}

fn default_print_width() -> usize {
    formatter::FormatOptions::default().print_width
}

impl From<WasmFormatOptions> for formatter::FormatOptions {
    fn from(opts: WasmFormatOptions) -> Self {
        Self {
            indent_size: opts.indent_size,
            print_width: opts.print_width,
        }
    }
}

/// Format HSML source, exposed as a WASM binding.
///
/// Returns the formatted HSML string, or a `JsError` on parse failure.
///
/// Options (all optional):
/// - `indentSize` — number of spaces per indentation level (default: 2)
/// - `printWidth` — maximum line width before wrapping attributes (default: 80)
#[wasm_bindgen(js_name = "formatContent")]
pub fn format_content(source: &str, options: JsValue) -> Result<String, JsError> {
    let options: formatter::FormatOptions = if options.is_undefined() || options.is_null() {
        formatter::FormatOptions::default()
    } else {
        let wasm_opts: WasmFormatOptions = serde_wasm_bindgen::from_value(options)
            .map_err(|e| JsError::new(&format!("Invalid formatContent options: {e}")))?;
        wasm_opts.into()
    };

    format_content_core(source, &options).map_err(|e| JsError::new(&e))
}

/// Convert HTML to HSML, exposed as a WASM binding.
///
/// Returns the converted HSML string, or a `JsError` on parse failure.
#[wasm_bindgen(js_name = "convertHtml")]
pub fn convert_html(html: &str) -> Result<String, JsError> {
    convert_html_core(html).map_err(|e| JsError::new(&e))
}

/// Compile HSML source to HTML, exposed as a WASM binding.
///
/// Returns the compiled HTML string, or a `JsError` on parse/compile failure.
#[wasm_bindgen(js_name = "compileContent")]
pub fn compile_content(source: &str) -> Result<String, JsError> {
    compile_content_core(source).map_err(|e| JsError::new(&e))
}

/// WASM result type that serializes to a JS object.
#[derive(Serialize)]
struct WasmCompileResult {
    success: bool,
    html: Option<String>,
    diagnostics: Vec<diagnostic::Diagnostic>,
}

/// WASM compile options that deserializes from a JS object.
#[derive(serde::Deserialize)]
#[serde(rename_all = "camelCase")]
struct WasmCompileOptions {
    #[serde(default)]
    pretty: bool,
    #[serde(default = "default_compile_indent_size")]
    indent_size: usize,
}

fn default_compile_indent_size() -> usize {
    compiler::HsmlCompileOptions::default().indent_size
}

impl From<WasmCompileOptions> for compiler::HsmlCompileOptions {
    fn from(opts: WasmCompileOptions) -> Self {
        Self {
            pretty: opts.pretty,
            indent_size: opts.indent_size,
        }
    }
}

/// Compile HSML source and return a JS object with HTML output and diagnostics.
///
/// Returns a JS object: `{ success: boolean, html: string | null, diagnostics: Diagnostic[] }`
///
/// Options (all optional):
/// - `pretty` — emit pretty-printed HTML with indentation (default: false)
/// - `indentSize` — number of spaces per indentation level (default: 2)
#[wasm_bindgen(js_name = "compileContentWithDiagnostics")]
pub fn compile_content_with_diagnostics(source: &str, options: JsValue) -> JsValue {
    let compile_options: compiler::HsmlCompileOptions =
        if options.is_undefined() || options.is_null() {
            compiler::HsmlCompileOptions::default()
        } else {
            let wasm_opts: WasmCompileOptions = match serde_wasm_bindgen::from_value(options) {
                Ok(opts) => opts,
                Err(_) => WasmCompileOptions {
                    pretty: false,
                    indent_size: default_compile_indent_size(),
                },
            };
            wasm_opts.into()
        };

    let result = match compile_content_diagnostics_with_options(source, &compile_options) {
        Ok(output) => WasmCompileResult {
            success: true,
            html: Some(output.html),
            diagnostics: output.diagnostics,
        },
        Err(diagnostics) => WasmCompileResult {
            success: false,
            html: None,
            diagnostics,
        },
    };

    let serializer = serde_wasm_bindgen::Serializer::json_compatible();
    use serde::Serialize;

    result.serialize(&serializer).unwrap_or_else(|e| {
        let fallback = WasmCompileResult {
            success: false,
            html: None,
            diagnostics: vec![diagnostic::Diagnostic::compiler_error(format!(
                "Failed to serialize compile result: {e}"
            ))],
        };
        fallback
            .serialize(&serializer)
            .expect("fallback WasmCompileResult serialization should always succeed")
    })
}