rolldown 0.1.0-x86_64-linux-gnu

data/rust/src/result.rs

@@ -0,0 +1,49 @@
+use std::ffi::CString;
+use std::os::raw::c_char;
+
+#[repr(C)]
+pub enum RolldownErrorCode {
+  None = 0,
+  Option,
+  Encoding,
+  Build,
+  Io,
+  Internal,
+  Panic,
+}
+
+#[repr(C)]
+pub struct RolldownResult {
+  pub value: *mut c_char,
+  pub value_len: usize,
+  pub error: *mut c_char,
+  pub code: RolldownErrorCode,
+}
+
+impl RolldownResult {
+  pub fn value(payload: String) -> Self {
+    let len = payload.len();
+
+    match CString::new(payload) {
+      Ok(value) => Self {
+        value: value.into_raw(),
+        value_len: len,
+        error: std::ptr::null_mut(),
+        code: RolldownErrorCode::None,
+      },
+      Err(_) => Self::error(RolldownErrorCode::Encoding, "the payload contained a null byte"),
+    }
+  }
+
+  pub fn error(code: RolldownErrorCode, message: impl Into<String>) -> Self {
+    let message = CString::new(message.into())
+      .unwrap_or_else(|_| CString::new("an error with no printable message").expect("no interior nul"));
+
+    Self {
+      value: std::ptr::null_mut(),
+      value_len: 0,
+      error: message.into_raw(),
+      code,
+    }
+  }
+}

data/sig/rolldown/asset.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/rolldown/asset.rb with RBS::Inline
+
+module Rolldown
+  class Asset
+    attr_reader filename: String
+
+    attr_reader names: Array[String]
+
+    attr_reader source: String?
+
+    # : (Hash[String, untyped]) -> Rolldown::Asset
+    def self.from_hash: (Hash[String, untyped]) -> Rolldown::Asset
+
+    # : (filename: String, names: Array[String], source: String?) -> void
+    def initialize: (filename: String, names: Array[String], source: String?) -> void
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/rolldown/backend.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/rolldown/backend.rb with RBS::Inline
+
+module Rolldown
+  module Backend
+    module Unavailable
+      # : (String) -> String
+      def build: (String) -> String
+
+      # : () -> String
+      def panic_for_test: () -> String
+
+      # : () -> String
+      def version: () -> String
+
+      # : () -> String
+      def rolldown_version: () -> String
+
+      private
+
+      # : (Symbol?) -> bot
+      def unavailable: (Symbol?) -> bot
+    end
+
+    extend Unavailable
+  end
+end

data/sig/rolldown/build_result.rbs

@@ -0,0 +1,47 @@
+# Generated from lib/rolldown/build_result.rb with RBS::Inline
+
+module Rolldown
+  class BuildResult
+    attr_reader chunks: Array[Rolldown::Chunk]
+
+    attr_reader assets: Array[Rolldown::Asset]
+
+    attr_reader warnings: Array[Rolldown::Diagnostic]
+
+    attr_reader errors: Array[Rolldown::Diagnostic]
+
+    attr_reader dir: String?
+
+    attr_reader cwd: String?
+
+    # : (String, ?String?, ?String?) -> Rolldown::BuildResult
+    def self.from_json: (String, ?String?, ?String?) -> Rolldown::BuildResult
+
+    # : (chunks: Array[Rolldown::Chunk], assets: Array[Rolldown::Asset], warnings: Array[Rolldown::Diagnostic], errors: Array[Rolldown::Diagnostic], failed: bool, ?dir: String?, ?cwd: String?) -> void
+    def initialize: (chunks: Array[Rolldown::Chunk], assets: Array[Rolldown::Asset], warnings: Array[Rolldown::Diagnostic], errors: Array[Rolldown::Diagnostic], failed: bool, ?dir: String?, ?cwd: String?) -> void
+
+    # : () -> bool
+    def failed?: () -> bool
+
+    # : () -> bool
+    def errors?: () -> bool
+
+    # : () -> bool
+    def warnings?: () -> bool
+
+    # : (?String?) -> Array[String]
+    def write: (?String?) -> Array[String]
+
+    # : () -> Rolldown::Chunk?
+    def entry: () -> Rolldown::Chunk?
+
+    # : (?strict: bool) -> Rolldown::BuildResult
+    def validate!: (?strict: bool) -> Rolldown::BuildResult
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/rolldown/chunk.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/rolldown/chunk.rb with RBS::Inline
+
+module Rolldown
+  class Chunk
+    attr_reader filename: String
+
+    attr_reader name: String
+
+    attr_reader code: String
+
+    attr_reader map: String?
+
+    attr_reader imports: Array[String]
+
+    attr_reader dynamic_imports: Array[String]
+
+    attr_reader exports: Array[String]
+
+    attr_reader module_ids: Array[String]
+
+    # : (Hash[String, untyped]) -> Rolldown::Chunk
+    def self.from_hash: (Hash[String, untyped]) -> Rolldown::Chunk
+
+    # : (filename: String, name: String, code: String, map: String?, entry: bool, dynamic_entry: bool, imports: Array[String], dynamic_imports: Array[String], exports: Array[String], module_ids: Array[String]) -> void
+    def initialize: (filename: String, name: String, code: String, map: String?, entry: bool, dynamic_entry: bool, imports: Array[String], dynamic_imports: Array[String], exports: Array[String], module_ids: Array[String]) -> void
+
+    # : () -> bool
+    def entry?: () -> bool
+
+    # : () -> bool
+    def dynamic_entry?: () -> bool
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/rolldown/diagnostic.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/rolldown/diagnostic.rb with RBS::Inline
+
+module Rolldown
+  class Diagnostic
+    attr_reader kind: String
+
+    attr_reader severity: String
+
+    attr_reader message: String
+
+    attr_reader file: String?
+
+    attr_reader line: Integer?
+
+    attr_reader column: Integer?
+
+    # : (Hash[String, untyped]) -> Rolldown::Diagnostic
+    def self.from_hash: (Hash[String, untyped]) -> Rolldown::Diagnostic
+
+    # : (kind: String, severity: String, message: String, file: String?, line: Integer?, column: Integer?) -> void
+    def initialize: (kind: String, severity: String, message: String, file: String?, line: Integer?, column: Integer?) -> void
+
+    # : () -> bool
+    def error?: () -> bool
+
+    # : () -> bool
+    def warning?: () -> bool
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/rolldown/errors.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/rolldown/errors.rb with RBS::Inline
+
+module Rolldown
+  class Error < StandardError
+  end
+
+  class OptionError < Error
+  end
+
+  class EncodingError < Error
+  end
+
+  class BuildError < Error
+  end
+
+  class IOError < Error
+  end
+
+  class InternalError < Error
+  end
+
+  class PanicError < InternalError
+  end
+end

data/sig/rolldown/options.rbs

@@ -0,0 +1,61 @@
+# Generated from lib/rolldown/options.rb with RBS::Inline
+
+module Rolldown
+  class Options
+    INPUT: Array[Symbol]
+
+    OUTPUT: Array[Symbol]
+
+    TRANSFORM: Array[Symbol]
+
+    KNOWN: Array[Symbol]
+
+    CALLABLE: Hash[Symbol, String]
+
+    # : (Hash[Symbol, untyped], ?String) -> String
+    def self.serialize: (Hash[Symbol, untyped], ?String) -> String
+
+    attr_reader options: Hash[Symbol, untyped]
+
+    # : (Hash[Symbol, untyped], ?String) -> void
+    def initialize: (Hash[Symbol, untyped], ?String) -> void
+
+    # : () -> Hash[Symbol, untyped]
+    def to_h: () -> Hash[Symbol, untyped]
+
+    # : (?untyped) -> String
+    def to_json: (?untyped) -> String
+
+    # : () -> String
+    def inspect: () -> String
+
+    private
+
+    # : (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+    def normalize: (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+
+    # : (untyped) -> Array[untyped]
+    def entries: (untyped) -> Array[untyped]
+
+    # : (untyped) -> Array[String]
+    def externals: (untyped) -> Array[String]
+
+    # : (Symbol, Array[Symbol], String) -> void
+    def refuse_nested: (Symbol, Array[Symbol], String) -> void
+
+    # : (Symbol) -> Array[Symbol]
+    def nested_keys: (Symbol) -> Array[Symbol]
+
+    # : () -> Array[Symbol]
+    def output_keys: () -> Array[Symbol]
+
+    # : (Hash[untyped, untyped]) -> Array[untyped]
+    def named: (Hash[untyped, untyped]) -> Array[untyped]
+
+    # : (String) -> void
+    def validate!: (String) -> void
+
+    # : () -> void
+    def refuse_callables: () -> void
+  end
+end

data/sig/rolldown/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/rolldown/version.rb with RBS::Inline
+
+module Rolldown
+  VERSION: ::String
+end

data/sig/rolldown.rbs

@@ -0,0 +1,12 @@
+# Generated from lib/rolldown.rb with RBS::Inline
+
+module Rolldown
+  # : (**untyped) -> Rolldown::BuildResult
+  def self.build: (**untyped) -> Rolldown::BuildResult
+
+  # : () -> String
+  def self.rolldown_version: () -> String
+
+  # : (Hash[Symbol, untyped]) -> String?
+  private def self.destination: (Hash[Symbol, untyped]) -> String?
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: rolldown
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: x86_64-linux-gnu
+authors:
+- Marco Roth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-09-01 00:00:00.000000000 Z
+dependencies: []
+description: Ruby bindings for Rolldown, the Rust bundler behind Vite.
+email:
+- marco.roth@intergga.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- ext/rolldown/extconf.rb
+- ext/rolldown/include/rolldown.h
+- ext/rolldown/rolldown.c
+- lib/rolldown.rb
+- lib/rolldown/3.2/rolldown.so
+- lib/rolldown/3.3/rolldown.so
+- lib/rolldown/3.4/rolldown.so
+- lib/rolldown/4.0/rolldown.so
+- lib/rolldown/asset.rb
+- lib/rolldown/backend.rb
+- lib/rolldown/build_result.rb
+- lib/rolldown/chunk.rb
+- lib/rolldown/diagnostic.rb
+- lib/rolldown/errors.rb
+- lib/rolldown/options.rb
+- lib/rolldown/version.rb
+- licenses/README.md
+- licenses/rolldown-MIT.txt
+- licenses/rolldown-THIRD-PARTY.txt
+- rolldown.gemspec
+- rust/Cargo.lock
+- rust/Cargo.toml
+- rust/build.rs
+- rust/cbindgen.toml
+- rust/rustfmt.toml
+- rust/src/build.rs
+- rust/src/lib.rs
+- rust/src/modules.rs
+- rust/src/options.rs
+- rust/src/payload.rs
+- rust/src/result.rs
+- sig/rolldown.rbs
+- sig/rolldown/asset.rbs
+- sig/rolldown/backend.rbs
+- sig/rolldown/build_result.rbs
+- sig/rolldown/chunk.rbs
+- sig/rolldown/diagnostic.rbs
+- sig/rolldown/errors.rbs
+- sig/rolldown/options.rbs
+- sig/rolldown/version.rbs
+homepage: https://github.com/marcoroth/rolldown-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/marcoroth/rolldown-ruby
+  source_code_uri: https://github.com/marcoroth/rolldown-ruby
+  changelog_uri: https://github.com/marcoroth/rolldown-ruby/releases
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Blazing Fast Rust-based bundler for JavaScript
+test_files: []