Typescript Stubgen Command

Cargo.toml

@@ -37,6 +37,7 @@ strip = true
 anyhow = "1.0.89"
 base64 = "0.22.1"
 heck = "0.5.0"
+indexmap = "2.4.0"
 log = "0.4.22"
 semver = "1.0.23"
 js-component-bindgen = { path = "./crates/js-component-bindgen" }
@@ -57,4 +58,5 @@ wit-parser = "0.217.0"
 xshell = "0.2.6"
 
 [dev-dependencies]
-anyhow = { workspace = true }
+anyhow = { workspace = true }
+xshell = { workspace = true }

crates/js-component-bindgen-component/src/lib.rs

@@ -1,7 +1,11 @@
 use std::path::PathBuf;
 
 use anyhow::Result;
-use js_component_bindgen::{generate_types, source::wit_parser::Resolve, transpile};
+use js_component_bindgen::{
+    generate_types, generate_typescript_stubs,
+    source::wit_parser::{PackageId, Resolve},
+    transpile,
+};
 
 /// Calls [`write!`] with the passed arguments and unwraps the result.
 ///
@@ -112,39 +116,10 @@ impl Guest for JsComponentBindgenComponent {
         name: String,
         opts: TypeGenerationOptions,
     ) -> Result<Vec<(String, Vec<u8>)>, String> {
-        let mut resolve = Resolve::default();
-
-        // Add features if specified
-        match opts.features {
-            Some(EnabledFeatureSet::List(ref features)) => {
-                for f in features.into_iter() {
-                    resolve.features.insert(f.to_string());
-                }
-            }
-            Some(EnabledFeatureSet::All) => {
-                resolve.all_features = true;
-            }
-            _ => {}
-        }
-
-        let ids = match opts.wit {
-            Wit::Source(source) => resolve
-                .push_str(format!("{name}.wit"), &source)
-                .map_err(|e| e.to_string())?,
-            Wit::Path(path) => {
-                let path = PathBuf::from(path);
-                if path.is_dir() {
-                    resolve.push_dir(&path).map_err(|e| e.to_string())?.0
-                } else {
-                    resolve.push_file(&path).map_err(|e| e.to_string())?
-                }
-            }
-            Wit::Binary(_) => todo!(),
-        };
-
+        let (resolve, id) = resolve_package(opts.wit, opts.features, Some(&name))?;
         let world_string = opts.world.map(|world| world.to_string());
         let world = resolve
-            .select_world(ids, world_string.as_deref())
+            .select_world(id, world_string.as_deref())
             .map_err(|e| e.to_string())?;
 
         let opts = js_component_bindgen::TranspileOpts {
@@ -166,4 +141,55 @@ impl Guest for JsComponentBindgenComponent {
 
         Ok(files)
     }
+
+    fn generate_typescript_stubs(opts: TypescriptStubOptions) -> Result<Files, String> {
+        let (resolve, id) = resolve_package(opts.wit, None, None).map_err(|e| e.to_string())?;
+        let world_string = opts.world.map(|world| world.to_string());
+        let world = resolve
+            .select_world(id, world_string.as_deref())
+            .map_err(|e| e.to_string())?;
+
+        let files = generate_typescript_stubs(resolve, world).map_err(|e| e.to_string())?;
+
+        Ok(files)
+    }
+}
+
+fn resolve_package(
+    wit: Wit,
+    features: Option<EnabledFeatureSet>,
+    name: Option<&str>,
+) -> Result<(Resolve, PackageId), String> {
+    let name = name.unwrap_or("world");
+    let mut resolve = Resolve::default();
+
+    // Add features if specified
+    match features {
+        Some(EnabledFeatureSet::List(ref features)) => {
+            for f in features.into_iter() {
+                resolve.features.insert(f.to_string());
+            }
+        }
+        Some(EnabledFeatureSet::All) => {
+            resolve.all_features = true;
+        }
+        _ => {}
+    }
+
+    let id = match wit {
+        Wit::Source(source) => resolve
+            .push_str(format!("{name}.wit"), &source)
+            .map_err(|e| e.to_string())?,
+        Wit::Path(path) => {
+            let path = PathBuf::from(path);
+            if path.is_dir() {
+                resolve.push_dir(&path).map_err(|e| e.to_string())?.0
+            } else {
+                resolve.push_file(&path).map_err(|e| e.to_string())?
+            }
+        }
+        Wit::Binary(_) => todo!(),
+    };
+
+    Ok((resolve, id))
 }

crates/js-component-bindgen-component/wit/js-component-bindgen.wit

@@ -93,6 +93,13 @@ world js-component-bindgen {
     features: option<enabled-feature-set>,
   }
 
+  record typescript-stub-options {
+    /// wit to generate typing from
+    wit: wit,
+    /// world to generate typing for
+    %world: option<string>,
+  }
+
   enum export-type {
     function,
     instance,
@@ -110,4 +117,6 @@ world js-component-bindgen {
   export generate: func(component: list<u8>, options: generate-options) -> result<transpiled, string>;
 
   export generate-types: func(name: string, options: type-generation-options) -> result<files, string>;
+
+  export generate-typescript-stubs: func(options: typescript-stub-options) -> result<files, string>;
 }

crates/js-component-bindgen/Cargo.toml

@@ -26,9 +26,10 @@ base64 = { workspace = true }
 heck = { workspace = true }
 log = { workspace = true }
 semver = { workspace = true }
-wasm-encoder = { workspace = true }
 wasmparser = { workspace = true }
 wasmtime-environ = { workspace = true, features = ['component-model'] }
 wit-bindgen-core = { workspace = true }
 wit-component = { workspace = true }
 wit-parser = { workspace = true }
+indexmap = { workspace = true }
+wasm-encoder = { workspace = true }

crates/js-component-bindgen/src/files.rs

@@ -29,3 +29,12 @@ impl Files {
         self.files.iter().map(|p| (p.0.as_str(), p.1.as_slice()))
     }
 }
+
+impl IntoIterator for Files {
+    type Item = (String, Vec<u8>);
+    type IntoIter = std::collections::btree_map::IntoIter<String, Vec<u8>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.files.into_iter()
+    }
+}

crates/js-component-bindgen/src/lib.rs

@@ -2,6 +2,7 @@ mod core;
 mod files;
 mod transpile_bindgen;
 mod ts_bindgen;
+mod ts_stubgen;
 
 pub mod esm_bindgen;
 pub mod function_bindgen;
@@ -70,11 +71,18 @@ pub fn generate_types(
     ts_bindgen(&name, &resolve, world_id, &opts, &mut files)
         .context("failed to generate Typescript bindings")?;
 
-    let mut files_out: Vec<(String, Vec<u8>)> = Vec::new();
-    for (name, source) in files.iter() {
-        files_out.push((name.to_string(), source.to_vec()));
-    }
-    Ok(files_out)
+    Ok(files.into_iter().collect())
+}
+
+pub fn generate_typescript_stubs(
+    resolve: Resolve,
+    world_id: WorldId,
+) -> Result<Vec<(String, Vec<u8>)>, anyhow::Error> {
+    let mut files = files::Files::default();
+
+    ts_stubgen::ts_stubgen(&resolve, world_id, &mut files)?;
+
+    Ok(files.into_iter().collect())
 }
 
 /// Generate the JS transpilation bindgen for a given Wasm component binary

crates/js-component-bindgen/src/source.rs

@@ -96,6 +96,12 @@ impl From<Source> for String {
     }
 }
 
+impl AsRef<str> for Source {
+    fn as_ref(&self) -> &str {
+        &self.s
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::Source;