oj 0.0.1

Rust-native build tool for React apps
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

// SPDX-License-Identifier: MIT
// Copyright (c) 2026 Raphael Amorim

mod build;

use std::path::PathBuf;

use anyhow::Context;
use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "oj", version, about = "A Rust-native build tool for React apps")]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    /// Start the dev server
    Dev {
        /// App root containing index.html (defaults to ./playground when present)
        root: Option<PathBuf>,
        #[arg(long, default_value_t = 5199)]
        port: u16,
        /// Full bundle mode: serve one registry-runtime chunk instead of
        /// native ESM modules (experimental)
        #[arg(long)]
        bundle: bool,
    },
    /// Compile one file and print the output (debugging aid)
    Compile {
        file: PathBuf,
        /// Production transform (no jsxDEV, no Fast Refresh instrumentation)
        #[arg(long)]
        prod: bool,
    },
    /// Production build (embedded Rolldown: shake, chunk, minify, hash)
    Build {
        /// App root containing index.html (defaults to ./playground when present)
        root: Option<PathBuf>,
        /// Output directory, relative to the app root
        #[arg(long, default_value = "dist")]
        out: PathBuf,
    },
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    match Cli::parse().command {
        Command::Dev { root, port, bundle } => {
            let root = root.unwrap_or_else(|| {
                let playground = PathBuf::from("playground");
                if playground.join("index.html").is_file() { playground } else { PathBuf::from(".") }
            });
            oj_server::DevServer { root, port, bundle }.run().await
        }
        Command::Compile { file, prod } => {
            let source = std::fs::read_to_string(&file)
                .with_context(|| format!("cannot read {}", file.display()))?;
            let opts = if prod {
                oj_compiler::CompileOptions::prod()
            } else {
                oj_compiler::CompileOptions::dev()
            };
            let output = oj_compiler::compile(&file, &source, &opts)?;
            println!("{}", output.code);
            Ok(())
        }
        Command::Build { root, out } => {
            let root = root.unwrap_or_else(|| {
                let playground = PathBuf::from("playground");
                if playground.join("index.html").is_file() { playground } else { PathBuf::from(".") }
            });
            build::build(root, out).await
        }
    }
}