Generate Typescript Declaration Modules and Stubs

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

@@ -2,8 +2,8 @@ use std::path::PathBuf;
 
 use anyhow::{Context, Result};
 use js_component_bindgen::{
-    generate_types,
-    source::wit_parser::{Resolve, UnresolvedPackage},
+    generate_types, generate_typescript_stubs,
+    source::wit_parser::{PackageId, Resolve, UnresolvedPackage},
     transpile,
 };
 
@@ -116,32 +116,8 @@ impl Guest for JsComponentBindgenComponent {
         name: String,
         opts: TypeGenerationOptions,
     ) -> Result<Vec<(String, Vec<u8>)>, String> {
-        let mut resolve = Resolve::default();
-        let id = match opts.wit {
-            Wit::Source(source) => {
-                let pkg = UnresolvedPackage::parse(&PathBuf::from(format!("{name}.wit")), &source)
-                    .map_err(|e| e.to_string())?;
-                resolve.push(pkg).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 {
-                    let contents = std::fs::read(&path)
-                        .with_context(|| format!("failed to read file {path:?}"))
-                        .map_err(|e| e.to_string())?;
-                    let text = match std::str::from_utf8(&contents) {
-                        Ok(s) => s,
-                        Err(_) => return Err("input file is not valid utf-8".into()),
-                    };
-                    let pkg = UnresolvedPackage::parse(&path, text).map_err(|e| e.to_string())?;
-                    resolve.push(pkg).map_err(|e| e.to_string())?
-                }
-            }
-            Wit::Binary(_) => todo!(),
-        };
-
+        let (resolve, id) =
+            resolve_package(opts.wit, Some(name.as_str())).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())
@@ -166,4 +142,45 @@ impl Guest for JsComponentBindgenComponent {
 
         Ok(files)
     }
+
+    fn generate_typescript_stubs(opts: TypescriptStubOptions) -> Result<Files, String> {
+        let (resolve, id) = resolve_package(opts.wit, 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_opt: Wit, name: Option<&str>) -> Result<(Resolve, PackageId)> {
+    let mut resolve = Resolve::default();
+    let id = match wit_opt {
+        Wit::Source(source) => {
+            let name = name.unwrap_or("world");
+            let pkg = UnresolvedPackage::parse(&PathBuf::from(format!("{name}.wit")), &source)?;
+            resolve.push(pkg)?
+        }
+        Wit::Path(path) => {
+            let path = PathBuf::from(path);
+            if path.is_dir() {
+                resolve.push_dir(&path)?.0
+            } else {
+                let contents = std::fs::read(&path)
+                    .with_context(|| format!("failed to read file {path:?}"))?;
+                let text = match std::str::from_utf8(&contents) {
+                    Ok(s) => s,
+                    Err(_) => anyhow::bail!("input file is not valid utf-8"),
+                };
+                let pkg = UnresolvedPackage::parse(&path, text)?;
+                resolve.push(pkg)?
+            }
+        }
+        Wit::Binary(_) => todo!(),
+    };
+
+    Ok((resolve, id))
 }

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

@@ -83,6 +83,13 @@ world js-component-bindgen {
     map: option<maps>,
   }
 
+  record typescript-stub-options {
+    /// wit to generate typing from
+    wit: wit,
+    /// world to generate typing for
+    %world: option<string>,
+  }
+
   enum export-type {
     function,
     instance,
@@ -100,4 +107,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/src/files.rs

@@ -25,7 +25,16 @@ impl Files {
         self.files.remove(name)
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = (&'_ str, &'_ [u8])> {
+    pub fn iter(&self) -> impl Iterator<Item = (&str, &[u8])> {
         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);
 
-    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;