dumpling 0.1.0

A fast JavaScript runtime and bundler in Rust
Documentation 
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use clap::{Parser, Subcommand};
use std::error::Error;
use std::path::PathBuf;
use tracing::{error, info};

use dumpling::error::Result;

#[derive(Parser)]
#[command(name = "dumpling")]
#[command(about = "A fast JavaScript runtime and bundler")]
pub struct Cli {
    #[command(subcommand)]
    pub command: Commands,
}

#[derive(Subcommand)]
pub enum Commands {
    /// Run a JavaScript file
    Run {
        /// The JavaScript file to execute
        file: PathBuf,
        /// Arguments to pass to the script
        #[arg(trailing_var_arg = true)]
        args: Vec<String>,
    },
/// Bundle JavaScript files
    Bundle {
        /// Entry point file
        entry: PathBuf,
        /// Output file
        #[arg(short, long)]
        output: PathBuf,
        /// Bundle format (iife, esm, cjs)
        #[arg(short, long, default_value = "esm")]
        format: String,
        /// Minify output
        #[arg(short, long)]
        minify: bool,
        /// Generate source map
        #[arg(long)]
        sourcemap: bool,
        /// Generate TypeScript declaration files
        #[arg(long)]
        declarations: bool,
        /// Enable code splitting
        #[arg(long)]
        split: bool,
        /// Vendor chunk size limit (KB)
        #[arg(long, default_value = "50")]
        vendor_size: usize,
    },
    /// Install packages
    Install {
        /// Package names to install
        #[arg(trailing_var_arg = true)]
        packages: Vec<String>,
        /// Save as dev dependency
        #[arg(short, long)]
        dev: bool,
    },
    /// Uninstall packages
    Uninstall {
        /// Package names to remove
        #[arg(trailing_var_arg = true)]
        packages: Vec<String>,
    },
    /// Remove packages not in package.json
    Prune,
    /// Initialize a new project
    Init {
        /// Project name
        #[arg(short, long)]
        name: Option<String>,
    },
    /// Start a development server
    Dev {
        /// Port to serve on
        #[arg(short, long, default_value = "3000")]
        port: u16,
        /// Host to bind to
        #[arg(short, long, default_value = "localhost")]
        host: String,
    },
    /// Run a script from package.json
    RunScript {
        /// Script name to run (e.g., build, test)
        script: String,
    },
    /// Scan for security vulnerabilities
    Audit {
        /// Output format (json, markdown)
        #[arg(short, long, default_value = "markdown")]
        format: String,
        /// Check license compliance
        #[arg(long)]
        licenses: bool,
    },
}

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();

    let cli = Cli::parse();

    if let Err(e) = run(cli).await {
        error!("Error: {}", e);
        // Show error source chain for debugging
        let mut source: Option<&(dyn Error + 'static)> = e.source();
        while let Some(s) = source {
            error!("  Caused by: {}", s);
            source = s.source();
        }
        std::process::exit(1);
    }
}

async fn run(cli: Cli) -> Result<()> {
    match cli.command {
        Commands::Run { file, args } => {
            info!("Running file: {:?}", file);
            dumpling::run_file(file, args).await?;
        }
        Commands::Bundle { entry, output, format, minify, sourcemap, declarations, split, vendor_size } => {
            info!("Bundling {:?} -> {:?}", entry, output);
            dumpling::bundle_with_splitting(entry, output, &format, minify, sourcemap, declarations, split, vendor_size).await?;
        }
        Commands::Install { packages, dev } => {
            info!("Installing packages: {:?}", packages);
            dumpling::install(packages, dev).await?;
        }
        Commands::Uninstall { packages } => {
            info!("Uninstalling packages: {:?}", packages);
            dumpling::uninstall(packages).await?;
        }
        Commands::Prune => {
            info!("Pruning unused packages");
            dumpling::prune().await?;
        }
        Commands::Init { name } => {
            info!("Initializing project");
            dumpling::init(name).await?;
        }
        Commands::Dev { port, host } => {
            info!("Starting dev server on {}:{}", host, port);
            dumpling::start_dev_server(host, port).await?;
        }
        Commands::RunScript { script } => {
            info!("Running script: {}", script);
            dumpling::run_script(script).await?;
        }
        Commands::Audit { format, licenses } => {
            info!("Running security audit");
            dumpling::security::audit(format, licenses).await?;
        }
    }

    Ok(())
}