rolldown 0.1.0-aarch64-linux-gnu

data/rust/Cargo.toml

@@ -0,0 +1,37 @@
+[workspace]
+
+[package]
+name = "rolldown-ruby-ffi"
+version = "0.1.0"
+edition = "2021"
+authors = ["Marco Roth <marco.roth@intergga.ch>"]
+description = "C FFI bindings for rolldown, used by the rolldown gem"
+license = "MIT"
+repository = "https://github.com/marcoroth/rolldown-ruby"
+publish = false
+
+[lib]
+name = "rolldown_ffi"
+path = "src/lib.rs"
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[dependencies]
+rolldown = "=1.2.6"
+rolldown_common = "=1.2.6"
+rolldown_error = "=1.2.6"
+rolldown_plugin = "=1.2.6"
+arcstr = "1"
+rolldown_utils = "=1.2.6"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "1", features = ["rt-multi-thread"] }
+
+[build-dependencies]
+cbindgen = "0.28"
+
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+strip = "symbols"
+panic = "unwind"

data/rust/build.rs

@@ -0,0 +1,55 @@
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+  let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+  let header_path = PathBuf::from(&crate_dir).join("../ext/rolldown/include/rolldown.h");
+
+  if let Ok(bindings) = cbindgen::generate(&crate_dir) {
+    if let Some(parent) = header_path.parent() {
+      let _ = std::fs::create_dir_all(parent);
+    }
+
+    bindings.write_to_file(&header_path);
+  }
+
+  let lock_path = PathBuf::from(&crate_dir).join("Cargo.lock");
+
+  println!("cargo:rerun-if-changed={}", lock_path.display());
+
+  println!(
+    "cargo:rerun-if-changed={}",
+    PathBuf::from(&crate_dir).join("src").display()
+  );
+
+  println!(
+    "cargo:rerun-if-changed={}",
+    PathBuf::from(&crate_dir).join("cbindgen.toml").display()
+  );
+
+  println!(
+    "cargo:rustc-env=ROLLDOWN_VERSION={}",
+    locked_version(&lock_path, "rolldown")
+  );
+}
+
+fn locked_version(lock_path: &PathBuf, package: &str) -> String {
+  let Ok(lock) = fs::read_to_string(lock_path) else {
+    return "unknown".to_string();
+  };
+
+  let mut lines = lock.lines();
+
+  while let Some(line) = lines.next() {
+    if line.trim() != format!("name = \"{package}\"") {
+      continue;
+    }
+
+    if let Some(version) = lines.next().and_then(|next| next.trim().strip_prefix("version = ")) {
+      return version.trim_matches('"').to_string();
+    }
+  }
+
+  "unknown".to_string()
+}

data/rust/cbindgen.toml

@@ -0,0 +1,24 @@
+language = "C"
+header = """/* Generated by cbindgen, do not edit manually */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>"""
+include_guard = "ROLLDOWN_H"
+no_includes = true
+
+[export]
+include = [
+  "RolldownResult",
+  "RolldownErrorCode",
+]
+
+[enum]
+rename_variants = "ScreamingSnakeCase"
+prefix_with_name = true
+
+[fn]
+sort_by = "None"
+
+[parse]
+parse_deps = false

data/rust/rustfmt.toml

@@ -0,0 +1,3 @@
+tab_spaces = 2
+max_width = 120
+edition = "2021"

data/rust/src/build.rs

@@ -0,0 +1,39 @@
+use rolldown::Bundler;
+
+use crate::options::Options;
+use crate::payload::BuildPayload;
+use crate::result::{RolldownErrorCode, RolldownResult};
+
+pub fn build(options_json: &str) -> RolldownResult {
+  let (options, plugins) = match Options::parse(options_json).and_then(Options::into_parts) {
+    Ok(parts) => parts,
+    Err(failure) => return failure,
+  };
+
+  let mut bundler = match Bundler::with_plugins(options, plugins) {
+    Ok(bundler) => bundler,
+    Err(batched) => return payload(BuildPayload::from_failure(batched)),
+  };
+
+  let runtime = match tokio::runtime::Builder::new_multi_thread().enable_all().build() {
+    Ok(runtime) => runtime,
+    Err(error) => {
+      return RolldownResult::error(
+        RolldownErrorCode::Internal,
+        format!("could not start a runtime: {error}"),
+      )
+    }
+  };
+
+  match runtime.block_on(bundler.generate()) {
+    Ok(output) => payload(BuildPayload::from_output(output)),
+    Err(batched) => payload(BuildPayload::from_failure(batched)),
+  }
+}
+
+fn payload(payload: BuildPayload) -> RolldownResult {
+  match serde_json::to_string(&payload) {
+    Ok(json) => RolldownResult::value(json),
+    Err(error) => RolldownResult::error(RolldownErrorCode::Internal, error.to_string()),
+  }
+}

data/rust/src/lib.rs

@@ -0,0 +1,92 @@
+use std::ffi::{CStr, CString};
+use std::os::raw::c_char;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+mod build;
+mod modules;
+mod options;
+mod payload;
+mod result;
+
+use result::{RolldownErrorCode, RolldownResult};
+
+/// # Safety
+///
+/// `options_json` must be a valid, nul-terminated UTF-8 string.
+#[no_mangle]
+pub unsafe extern "C" fn rolldown_build(options_json: *const c_char) -> RolldownResult {
+  let Some(options) = borrow(options_json) else {
+    return RolldownResult::error(RolldownErrorCode::Encoding, "options were not valid UTF-8");
+  };
+
+  match catch_unwind(AssertUnwindSafe(|| build::build(options))) {
+    Ok(result) => result,
+    Err(payload) => RolldownResult::error(RolldownErrorCode::Panic, panic_message(&payload)),
+  }
+}
+
+#[no_mangle]
+pub extern "C" fn rolldown_version() -> *mut c_char {
+  into_c_string(env!("CARGO_PKG_VERSION"))
+}
+
+#[no_mangle]
+pub extern "C" fn rolldown_rolldown_version() -> *mut c_char {
+  into_c_string(env!("ROLLDOWN_VERSION"))
+}
+
+/// # Safety
+///
+/// `value` must be a pointer this library returned, and must not be used afterwards.
+#[no_mangle]
+pub unsafe extern "C" fn rolldown_string_free(value: *mut c_char) {
+  if value.is_null() {
+    return;
+  }
+
+  drop(CString::from_raw(value));
+}
+
+/// # Safety
+///
+/// `result` must be one this library returned, and must not be used afterwards.
+#[no_mangle]
+pub unsafe extern "C" fn rolldown_result_free(result: RolldownResult) {
+  if !result.value.is_null() {
+    drop(CString::from_raw(result.value));
+  }
+
+  if !result.error.is_null() {
+    drop(CString::from_raw(result.error));
+  }
+}
+
+#[no_mangle]
+pub extern "C" fn rolldown_panic_for_test() -> RolldownResult {
+  match catch_unwind(AssertUnwindSafe(|| -> RolldownResult { panic!("a deliberate panic") })) {
+    Ok(result) => result,
+    Err(payload) => RolldownResult::error(RolldownErrorCode::Panic, panic_message(&payload)),
+  }
+}
+
+unsafe fn borrow<'a>(value: *const c_char) -> Option<&'a str> {
+  if value.is_null() {
+    return None;
+  }
+
+  CStr::from_ptr(value).to_str().ok()
+}
+
+fn panic_message(payload: &Box<dyn std::any::Any + Send>) -> String {
+  payload
+    .downcast_ref::<&str>()
+    .map(|message| (*message).to_string())
+    .or_else(|| payload.downcast_ref::<String>().cloned())
+    .unwrap_or_else(|| "rolldown panicked".to_string())
+}
+
+fn into_c_string(value: &str) -> *mut c_char {
+  CString::new(value)
+    .unwrap_or_else(|_| CString::new("unknown").expect("a string with no interior nul"))
+    .into_raw()
+}

data/rust/src/modules.rs

@@ -0,0 +1,89 @@
+use std::borrow::Cow;
+use std::collections::BTreeMap;
+use std::path::{Component, Path, PathBuf};
+
+use arcstr::ArcStr;
+use rolldown_plugin::{
+  HookLoadArgs, HookLoadOutput, HookLoadReturn, HookResolveIdArgs, HookResolveIdOutput, HookResolveIdReturn, HookUsage,
+  Plugin, PluginContext, SharedLoadPluginContext,
+};
+
+#[derive(Debug)]
+pub struct VirtualModules {
+  sources: BTreeMap<String, ArcStr>,
+}
+
+impl VirtualModules {
+  pub fn new(sources: BTreeMap<String, String>) -> Self {
+    Self {
+      sources: sources.into_iter().map(|(id, code)| (id, ArcStr::from(code))).collect(),
+    }
+  }
+}
+
+impl Plugin for VirtualModules {
+  fn name(&self) -> Cow<'static, str> {
+    Cow::Borrowed("rolldown-ruby:modules")
+  }
+
+  fn register_hook_usage(&self) -> HookUsage {
+    HookUsage::ResolveId | HookUsage::Load
+  }
+
+  async fn resolve_id(&self, _ctx: &PluginContext, args: &HookResolveIdArgs<'_>) -> HookResolveIdReturn {
+    if self.sources.contains_key(args.specifier) {
+      return Ok(Some(HookResolveIdOutput {
+        id: ArcStr::from(args.specifier),
+        ..Default::default()
+      }));
+    }
+
+    let Some(importer) = args.importer else {
+      return Ok(None);
+    };
+
+    if !self.sources.contains_key(importer) || !args.specifier.starts_with('.') {
+      return Ok(None);
+    }
+
+    let Some(directory) = Path::new(importer).parent() else {
+      return Ok(None);
+    };
+
+    let Some(resolved) = normalize(&directory.join(args.specifier)) else {
+      return Ok(None);
+    };
+
+    Ok(Some(HookResolveIdOutput {
+      id: ArcStr::from(resolved),
+      ..Default::default()
+    }))
+  }
+
+  async fn load(&self, _ctx: SharedLoadPluginContext, args: &HookLoadArgs<'_>) -> HookLoadReturn {
+    let Some(code) = self.sources.get(args.id) else {
+      return Ok(None);
+    };
+
+    Ok(Some(HookLoadOutput {
+      code: code.clone(),
+      ..Default::default()
+    }))
+  }
+}
+
+fn normalize(path: &Path) -> Option<String> {
+  let mut normalized = PathBuf::new();
+
+  for component in path.components() {
+    match component {
+      Component::CurDir => {}
+      Component::ParentDir => {
+        normalized.pop();
+      }
+      other => normalized.push(other),
+    }
+  }
+
+  normalized.to_str().map(ToOwned::to_owned)
+}

data/rust/src/options.rs

@@ -0,0 +1,251 @@
+use std::path::PathBuf;
+
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use rolldown::{
+  AddonOutputOption, AssetFilenamesOutputOption, BundlerOptions, ChunkFilenamesOutputOption, InputItem, IsExternal,
+  LegalComments, OutputExports, OutputFormat, Platform, RawMinifyOptions, SourceMapType, TreeshakeOptions,
+};
+
+use rolldown_common::ModuleType;
+use rolldown_plugin::Pluginable;
+use rolldown_utils::pattern_filter::StringOrRegex;
+use serde::Deserialize;
+
+use crate::modules::VirtualModules;
+use crate::result::{RolldownErrorCode, RolldownResult};
+
+#[derive(Deserialize, Default)]
+#[serde(default, deny_unknown_fields)]
+pub struct Options {
+  pub input: Vec<Input>,
+  pub cwd: Option<String>,
+  pub external: Vec<String>,
+  pub platform: Option<String>,
+  pub treeshake: Option<bool>,
+  pub module_types: BTreeMap<String, String>,
+  pub modules: BTreeMap<String, String>,
+  pub transform: Transform,
+  pub shim_missing_exports: Option<bool>,
+  pub output: Output,
+}
+
+#[derive(Deserialize, Default)]
+#[serde(default, deny_unknown_fields)]
+pub struct Transform {
+  pub define: BTreeMap<String, String>,
+}
+
+#[derive(Deserialize, Default)]
+#[serde(default, deny_unknown_fields)]
+pub struct Output {
+  pub dir: Option<String>,
+  pub file: Option<String>,
+  pub format: Option<String>,
+  pub name: Option<String>,
+  pub exports: Option<String>,
+  pub sourcemap: Option<SourceMap>,
+  pub minify: Option<Minify>,
+  pub banner: Option<String>,
+  pub footer: Option<String>,
+  pub intro: Option<String>,
+  pub outro: Option<String>,
+  pub entry_file_names: Option<String>,
+  pub chunk_file_names: Option<String>,
+  pub asset_file_names: Option<String>,
+  pub keep_names: Option<bool>,
+  pub legal_comments: Option<String>,
+  pub es_module: Option<bool>,
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum Input {
+  Bare(String),
+  Named { name: Option<String>, import: String },
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum SourceMap {
+  Toggle(bool),
+  Kind(String),
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum Minify {
+  Toggle(bool),
+  Kind(String),
+}
+
+impl Options {
+  pub fn parse(json: &str) -> Result<Self, RolldownResult> {
+    serde_json::from_str(json).map_err(|error| RolldownResult::error(RolldownErrorCode::Option, error.to_string()))
+  }
+
+  pub fn into_parts(mut self) -> Result<(BundlerOptions, Vec<Arc<dyn Pluginable>>), RolldownResult> {
+    let modules = std::mem::take(&mut self.modules);
+
+    let plugins: Vec<Arc<dyn Pluginable>> = if modules.is_empty() {
+      Vec::new()
+    } else {
+      vec![Arc::new(VirtualModules::new(modules))]
+    };
+
+    Ok((self.into_bundler_options()?, plugins))
+  }
+
+  fn into_bundler_options(self) -> Result<BundlerOptions, RolldownResult> {
+    if self.input.is_empty() {
+      return Err(RolldownResult::error(RolldownErrorCode::Option, "input is required"));
+    }
+
+    let input = self
+      .input
+      .into_iter()
+      .map(|entry| match entry {
+        Input::Bare(import) => InputItem { name: None, import },
+        Input::Named { name, import } => InputItem { name, import },
+      })
+      .collect();
+
+    let output = self.output;
+
+    Ok(BundlerOptions {
+      input: Some(input),
+      cwd: self.cwd.map(PathBuf::from),
+      platform: self.platform.as_deref().map(platform).transpose()?,
+      external: external(self.external),
+      define: (!self.transform.define.is_empty()).then(|| self.transform.define.into_iter().collect()),
+      treeshake: self
+        .treeshake
+        .map_or(TreeshakeOptions::Boolean(true), TreeshakeOptions::Boolean),
+      shim_missing_exports: self.shim_missing_exports,
+      module_types: module_types(self.module_types)?.map(|pairs| pairs.into_iter().collect()),
+      dir: output.dir,
+      file: output.file,
+      format: output.format.as_deref().map(format).transpose()?,
+      name: output.name,
+      exports: output.exports.as_deref().map(exports).transpose()?,
+      sourcemap: sourcemap(output.sourcemap)?,
+      minify: minify(output.minify)?,
+      banner: addon(output.banner),
+      footer: addon(output.footer),
+      intro: addon(output.intro),
+      outro: addon(output.outro),
+      entry_filenames: output.entry_file_names.map(ChunkFilenamesOutputOption::String),
+      chunk_filenames: output.chunk_file_names.map(ChunkFilenamesOutputOption::String),
+      asset_filenames: output.asset_file_names.map(AssetFilenamesOutputOption::String),
+      keep_names: output.keep_names,
+      legal_comments: output.legal_comments.as_deref().map(legal_comments).transpose()?,
+      es_module: output.es_module.map(Into::into),
+      ..Default::default()
+    })
+  }
+}
+
+fn module_types(given: BTreeMap<String, String>) -> Result<Option<Vec<(String, ModuleType)>>, RolldownResult> {
+  if given.is_empty() {
+    return Ok(None);
+  }
+
+  given
+    .into_iter()
+    .map(|(extension, name)| {
+      let module_type = ModuleType::from_known_str(&name).map_err(|_| {
+        unknown(
+          "module type",
+          &name,
+          "js, jsx, ts, tsx, json, text, base64, dataurl, binary, empty, css, asset or copy",
+        )
+      })?;
+
+      Ok((extension, module_type))
+    })
+    .collect::<Result<Vec<_>, _>>()
+    .map(Some)
+}
+
+fn external(patterns: Vec<String>) -> Option<IsExternal> {
+  if patterns.is_empty() {
+    return None;
+  }
+
+  Some(IsExternal::StringOrRegex(
+    patterns.into_iter().map(StringOrRegex::String).collect(),
+  ))
+}
+
+fn addon(value: Option<String>) -> Option<AddonOutputOption> {
+  value.map(|text| AddonOutputOption::String(Some(text)))
+}
+
+fn sourcemap(value: Option<SourceMap>) -> Result<Option<SourceMapType>, RolldownResult> {
+  match value {
+    None | Some(SourceMap::Toggle(false)) => Ok(None),
+    Some(SourceMap::Toggle(true)) => Ok(Some(SourceMapType::File)),
+    Some(SourceMap::Kind(kind)) => match kind.as_str() {
+      "file" => Ok(Some(SourceMapType::File)),
+      "inline" => Ok(Some(SourceMapType::Inline)),
+      "hidden" => Ok(Some(SourceMapType::Hidden)),
+      other => Err(unknown("sourcemap", other, "true, false, file, inline or hidden")),
+    },
+  }
+}
+
+fn minify(value: Option<Minify>) -> Result<Option<RawMinifyOptions>, RolldownResult> {
+  match value {
+    None => Ok(None),
+    Some(Minify::Toggle(toggle)) => Ok(Some(RawMinifyOptions::Bool(toggle))),
+    Some(Minify::Kind(kind)) => match kind.as_str() {
+      "dce-only" => Ok(Some(RawMinifyOptions::DeadCodeEliminationOnly)),
+      other => Err(unknown("minify", other, "true, false or dce-only")),
+    },
+  }
+}
+
+fn format(value: &str) -> Result<OutputFormat, RolldownResult> {
+  match value {
+    "esm" => Ok(OutputFormat::Esm),
+    "cjs" => Ok(OutputFormat::Cjs),
+    "iife" => Ok(OutputFormat::Iife),
+    "umd" => Ok(OutputFormat::Umd),
+    other => Err(unknown("format", other, "esm, cjs, iife or umd")),
+  }
+}
+
+fn platform(value: &str) -> Result<Platform, RolldownResult> {
+  match value {
+    "browser" => Ok(Platform::Browser),
+    "node" => Ok(Platform::Node),
+    "neutral" => Ok(Platform::Neutral),
+    other => Err(unknown("platform", other, "browser, node or neutral")),
+  }
+}
+
+fn exports(value: &str) -> Result<OutputExports, RolldownResult> {
+  match value {
+    "auto" => Ok(OutputExports::Auto),
+    "named" => Ok(OutputExports::Named),
+    "default" => Ok(OutputExports::Default),
+    "none" => Ok(OutputExports::None),
+    other => Err(unknown("exports", other, "auto, named, default or none")),
+  }
+}
+
+fn legal_comments(value: &str) -> Result<LegalComments, RolldownResult> {
+  match value {
+    "none" => Ok(LegalComments::None),
+    "inline" => Ok(LegalComments::Inline),
+    other => Err(unknown("legal_comments", other, "none or inline")),
+  }
+}
+
+fn unknown(option: &str, given: &str, expected: &str) -> RolldownResult {
+  RolldownResult::error(
+    RolldownErrorCode::Option,
+    format!("Unknown {option}: {given}. Expected {expected}."),
+  )
+}

data/rust/src/payload.rs

@@ -0,0 +1,104 @@
+use rolldown::BundleOutput;
+use rolldown_common::Output;
+use rolldown_error::{BatchedBuildDiagnostic, BuildDiagnostic};
+use serde::Serialize;
+
+#[derive(Serialize, Default)]
+pub struct BuildPayload {
+  pub chunks: Vec<Chunk>,
+  pub assets: Vec<Asset>,
+  pub warnings: Vec<Diagnostic>,
+  pub errors: Vec<Diagnostic>,
+  pub failed: bool,
+}
+
+#[derive(Serialize)]
+pub struct Chunk {
+  pub filename: String,
+  pub name: String,
+  pub code: String,
+  pub map: Option<String>,
+  pub is_entry: bool,
+  pub is_dynamic_entry: bool,
+  pub imports: Vec<String>,
+  pub dynamic_imports: Vec<String>,
+  pub exports: Vec<String>,
+  pub module_ids: Vec<String>,
+}
+
+#[derive(Serialize)]
+pub struct Asset {
+  pub filename: String,
+  pub names: Vec<String>,
+  pub source: Option<String>,
+}
+
+#[derive(Serialize)]
+pub struct Diagnostic {
+  pub kind: String,
+  pub severity: String,
+  pub message: String,
+  pub file: Option<String>,
+  pub line: Option<usize>,
+  pub column: Option<usize>,
+}
+
+impl BuildPayload {
+  pub fn from_output(output: BundleOutput) -> Self {
+    let mut payload = Self {
+      warnings: convert(&output.warnings),
+      ..Default::default()
+    };
+
+    for asset in output.assets {
+      match asset {
+        Output::Chunk(chunk) => payload.chunks.push(Chunk {
+          filename: chunk.filename.to_string(),
+          name: chunk.name.to_string(),
+          code: chunk.code.clone(),
+          map: chunk.map.as_ref().map(|map| map.to_json_string()),
+          is_entry: chunk.is_entry,
+          is_dynamic_entry: chunk.is_dynamic_entry,
+          imports: chunk.imports.iter().map(ToString::to_string).collect(),
+          dynamic_imports: chunk.dynamic_imports.iter().map(ToString::to_string).collect(),
+          exports: chunk.exports.iter().map(ToString::to_string).collect(),
+          module_ids: chunk.module_ids.iter().map(ToString::to_string).collect(),
+        }),
+        Output::Asset(asset) => payload.assets.push(Asset {
+          filename: asset.filename.to_string(),
+          names: asset.names.clone(),
+          source: asset.source.clone().try_into_string().ok(),
+        }),
+      }
+    }
+
+    payload
+  }
+
+  pub fn from_failure(batched: BatchedBuildDiagnostic) -> Self {
+    Self {
+      errors: convert(&batched.into_vec()),
+      failed: true,
+      ..Default::default()
+    }
+  }
+}
+
+fn convert(diagnostics: &[BuildDiagnostic]) -> Vec<Diagnostic> {
+  diagnostics
+    .iter()
+    .map(|diagnostic| {
+      let rendered = diagnostic.to_diagnostic();
+      let location = rendered.get_primary_location();
+
+      Diagnostic {
+        kind: diagnostic.kind().to_string(),
+        severity: format!("{:?}", diagnostic.severity()).to_lowercase(),
+        message: rendered.convert_to_string(false),
+        file: location.as_ref().map(|(file, ..)| file.clone()),
+        line: location.as_ref().map(|(_, line, ..)| *line),
+        column: location.as_ref().map(|(_, _, column, _)| *column),
+      }
+    })
+    .collect()
+}