Combine #195 with e2e

e2e/dependencies/consumer/.cargo/config.toml

@@ -0,0 +1,2 @@
+[env]
+TS_RS_EXPORT_DIR = { value = "./bindings/", relative = true }

e2e/dependencies/dependency1/src/lib.rs

@@ -1,6 +1,12 @@
 use ts_rs::TS;
 
 #[derive(TS)]
+#[ts(export)]
 pub struct LibraryType {
     pub a: i32
-}
+}
+
+#[test]
+fn env_set() {
+    assert_ne!(env!("TS_RS_EXPORT_DIR"), "");
+}

e2e/workspace/.cargo/config.toml

@@ -0,0 +1,2 @@
+[env]
+TS_RS_EXPORT_DIR = { value = "./bindings/", relative = true }

e2e/workspace/crate1/src/lib.rs

@@ -1,6 +1,7 @@
 use ts_rs::TS;
 
 #[derive(TS)]
+#[ts(export)]
 pub struct Crate1 {
     pub x: i32
-}
+}

e2e/workspace/crate2/src/lib.rs

@@ -1,6 +1,7 @@
 use ts_rs::TS;
 
 #[derive(TS)]
+#[ts(export)]
 pub struct Crate2 {
     pub x: i32
 }

macros/src/lib.rs

@@ -47,12 +47,18 @@ impl DerivedTS {
     }
 
     fn into_impl(self, rust_ty: Ident, generics: Generics) -> TokenStream {
+        let mut get_export_to = quote! {};
         let export_to = match &self.export_to {
             Some(dirname) if dirname.ends_with('/') => {
                 format!("{}{}.ts", dirname, self.name)
             }
             Some(filename) => filename.clone(),
             None => {
+                get_export_to = quote! {
+                    fn get_export_to() -> Option<String> {
+                        ts_rs::__private::get_export_to_path::<Self>()
+                    }
+                };
                 format!("bindings/{}.ts", self.name)
             }
         };
@@ -84,6 +90,7 @@ impl DerivedTS {
         quote! {
             #impl_start {
                 const EXPORT_TO: Option<&'static str> = Some(#export_to);
+                #get_export_to
 
                 fn decl() -> String {
                     #decl

ts-rs/src/export.rs

@@ -3,6 +3,7 @@ use std::{
     collections::BTreeMap,
     fmt::Write,
     path::{Component, Path, PathBuf},
+    sync::OnceLock,
 };
 
 use thiserror::Error;
@@ -59,6 +60,29 @@ pub(crate) fn export_type_to<T: TS + ?Sized + 'static, P: AsRef<Path>>(
     Ok(())
 }
 
+
+#[doc(hidden)]
+pub mod __private {
+    use super::*;
+
+    const EXPORT_DIR_ENV_VAR: &str = "TS_RS_EXPORT_DIR";
+    fn provided_default_dir() -> &'static Option<String> {
+        static EXPORT_TO: OnceLock<Option<String>> = OnceLock::new();
+        EXPORT_TO.get_or_init(|| std::env::var(EXPORT_DIR_ENV_VAR).ok())
+    }
+
+    /// Returns the path to where `T` should be exported using the `TS_RS_EXPORT_DIR` environment variable.
+    ///
+    /// This should only be used by the TS derive macro; the `get_export_to` trait method should not
+    /// be overridden if the `#[ts(export_to = ..)]` attribute exists.
+    pub fn get_export_to_path<T: TS + ?Sized>() -> Option<String> {
+        provided_default_dir().as_ref().map_or_else(
+            || T::EXPORT_TO.map(ToString::to_string),
+            |path| Some(format!("{path}/{}.ts", T::name())),
+        )
+    }
+}
+
 /// Returns the generated defintion for `T`.
 pub(crate) fn export_type_to_string<T: TS + ?Sized + 'static>() -> Result<String, ExportError> {
     let mut buffer = String::with_capacity(1024);
@@ -72,7 +96,7 @@ pub(crate) fn export_type_to_string<T: TS + ?Sized + 'static>() -> Result<String
 fn output_path<T: TS + ?Sized>() -> Result<PathBuf, ExportError> {
     let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").map_err(|_| ManifestDirNotSet)?;
     let manifest_dir = Path::new(&manifest_dir);
-    let path = PathBuf::from(T::EXPORT_TO.ok_or(CannotBeExported)?);
+    let path = PathBuf::from(T::get_export_to().ok_or(CannotBeExported)?);
     Ok(manifest_dir.join(path))
 }
 
@@ -84,7 +108,8 @@ fn generate_decl<T: TS + ?Sized>(out: &mut String) {
 
 /// Push an import statement for all dependencies of `T`
 fn generate_imports<T: TS + ?Sized + 'static>(out: &mut String) -> Result<(), ExportError> {
-    let path = Path::new(T::EXPORT_TO.ok_or(ExportError::CannotBeExported)?);
+    let export_to = T::get_export_to().ok_or(CannotBeExported)?;
+    let path = Path::new(&export_to);
 
     let deps = T::dependencies();
     let deduplicated_deps = deps
@@ -94,7 +119,7 @@ fn generate_imports<T: TS + ?Sized + 'static>(out: &mut String) -> Result<(), Ex
         .collect::<BTreeMap<_, _>>();
 
     for (_, dep) in deduplicated_deps {
-        let rel_path = import_path(path, Path::new(dep.exported_to));
+        let rel_path = import_path(path, Path::new(&dep.exported_to));
         writeln!(
             out,
             "import type {{ {} }} from {:?};",

ts-rs/src/lib.rs

@@ -167,7 +167,7 @@ use std::{
 
 pub use ts_rs_macros::TS;
 
-pub use crate::export::ExportError;
+pub use crate::export::{ExportError, __private};
 
 #[cfg(feature = "chrono-impl")]
 mod chrono;
@@ -263,6 +263,10 @@ mod export;
 pub trait TS {
     const EXPORT_TO: Option<&'static str> = None;
 
+    fn get_export_to() -> Option<String> {
+        Self::EXPORT_TO.map(ToString::to_string)
+    }
+
     /// Declaration of this type, e.g. `interface User { user_id: number, ... }`.
     /// This function will panic if the type has no declaration.
     fn decl() -> String {
@@ -342,15 +346,15 @@ pub struct Dependency {
     pub ts_name: String,
     /// Path to where the type would be exported. By default a filename is derived from the types
     /// name, which can be customized with `#[ts(export_to = "..")]`.
-    pub exported_to: &'static str,
+    pub exported_to: String,
 }
 
 impl Dependency {
     /// Constructs a [`Dependency`] from the given type `T`.
     /// If `T` is not exportable (meaning `T::EXPORT_TO` is `None`), this function will return
     /// `None`
     pub fn from_ty<T: TS + 'static + ?Sized>() -> Option<Self> {
-        let exported_to = T::EXPORT_TO?;
+        let exported_to = T::get_export_to()?;
         Some(Dependency {
             type_id: TypeId::of::<T>(),
             ts_name: T::name(),