jsx-generator 1.0.0

JSX code generator with formatting, optimization, and minification capabilities
Documentation
use jsx_generator::{CodeEmitter, CodeFormatter, CodeOptimizer};
use jsxbin_parser::types::{Block, Token};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== JSX Code Generator Examples ===\n");

    // Example 1: Simple tokens
    println!("Example 1: Emit simple tokens");
    let mut emitter = CodeEmitter::default();

    let tokens = vec![
        Token::StringLiteral("hello".to_string()),
        Token::NumberLiteral(42.0),
        Token::BooleanLiteral(true),
    ];

    for token in &tokens {
        let code = emitter.emit_token(token)?;
        println!("  {:?} → {}", token, code);
    }

    // Example 2: Function declaration
    println!("\nExample 2: Function declaration");
    let func_token = Token::Function {
        name: "add".to_string(),
        params: vec!["a".to_string(), "b".to_string()],
        body: Box::new(Block {
            statements: vec![Token::ReturnStatement(Some(
                Box::new(Token::BinaryOperation {
                    left: Box::new(Token::Identifier("a".to_string()).into()),
                    operator: "+".to_string(),
                    right: Box::new(Token::Identifier("b".to_string()).into()),
                }.into()),
            ))],
        }),
    };

    let code = emitter.emit_token(&func_token)?;
    println!("  Generated:\n{}\n", code);

    // Example 3: Formatting
    println!("Example 3: Code formatting");
    let unformatted = "var x={a:1,b:2};if(x.a>0){return true;}";
    let formatter = CodeFormatter::default();
    let formatted = formatter.format(unformatted)?;
    println!("  Before:\n{}\n", unformatted);
    println!("  After:\n{}\n", formatted);

    // Example 4: Minification
    println!("Example 4: Minification");
    let verbose = "var message = \"hello world\"; console.log(message);";
    let minified = formatter.minify(verbose)?;
    println!("  Before: {}", verbose);
    println!("  After:  {}\n", minified);

    // Example 5: Optimization
    println!("Example 5: Constant folding");
    let optimizer = CodeOptimizer::default();
    let result = optimizer.fold_numeric_operation(2.0, "*", 3.0)?;
    println!("  2 * 3 = {}\n", result);

    // Example 6: Array literal
    println!("Example 6: Array and object literals");
    let array = Token::ArrayLiteral(vec![
        Token::NumberLiteral(1.0).into(),
        Token::NumberLiteral(2.0).into(),
        Token::NumberLiteral(3.0).into(),
    ]);
    let array_code = emitter.emit_token(&array)?;
    println!("  Array: {}\n", array_code);

    let obj = Token::ObjectLiteral(vec![
        (
            "name".to_string(),
            Token::StringLiteral("test".to_string()).into(),
        ),
        ("value".to_string(), Token::NumberLiteral(42.0).into()),
    ]);
    let obj_code = emitter.emit_token(&obj)?;
    println!("  Object:\n{}\n", obj_code);

    println!("✅ All examples completed successfully!");

    Ok(())
}