Make #[ts(export_to = "...")] relative to TS_RS_EXPORT_DIR

.github/workflows/test.yml

@@ -18,7 +18,8 @@ jobs:
         working-directory: e2e/dependencies/consumer
         run: |
           TS_RS_EXPORT_DIR=custom-bindings cargo t 
-          tsc custom-bindings/* --noEmit --noUnusedLocals --strict
+          shopt -s globstar
+          tsc custom-bindings/**/*.ts --noEmit --noUnusedLocals --strict
   e2e-workspace:
     name: Run 'workspace' end-to-end test
     runs-on: ubuntu-latest
@@ -36,7 +37,8 @@ jobs:
         working-directory: e2e/workspace
         run: |
           TS_RS_EXPORT_DIR=custom-bindings cargo t 
-          tsc parent/custom-bindings/* --noEmit --noUnusedLocals --strict
+          shopt -s globstar
+          tsc parent/custom-bindings/**/*.ts --noEmit --noUnusedLocals --strict
   e2e-example:
     name: End-to-end test example
     runs-on: ubuntu-latest
@@ -54,7 +56,8 @@ jobs:
         working-directory: example
         run: |
           TS_RS_EXPORT_DIR=custom-bindings cargo t 
-          tsc custom-bindings/* --noEmit --noUnusedLocals --strict
+          shopt -s globstar
+          tsc custom-bindings/**/*.ts --noEmit --noUnusedLocals --strict
 
   readme-up-to-date:
     name: Check that README.md is up-to-date
@@ -78,6 +81,11 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
+      - name: Test with export env
+        run: |
+          TS_RS_EXPORT_DIR=output cargo test --no-default-features
+          shopt -s globstar
+          tsc ts-rs/output/tests-out/**/*.ts --noEmit --noUnusedLocals --strict
       - name: No features
         run: |
           cargo test --no-default-features

macros/src/lib.rs

@@ -30,26 +30,22 @@ struct DerivedTS {
 
 impl DerivedTS {
     fn into_impl(mut 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.ts_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.ts_name)
-            }
-        };
-
         let export = self
             .export
             .then(|| self.generate_export_test(&rust_ty, &generics));
 
+        let export_to = {
+            let path = match self.export_to.as_deref() {
+                Some(dirname) if dirname.ends_with('/') => format!("{}{}.ts", dirname, self.ts_name),
+                Some(filename) => filename.to_owned(),
+                None => format!("bindings/{}.ts", self.ts_name),
+            };
+
+            quote! {
+                const EXPORT_TO: Option<&'static str> = Some(#path);
+            }
+        };
+
         let docs = match &*self.docs {
             "" => None,
             docs => Some(quote!(const DOCS: Option<&'static str> = Some(#docs);)),
@@ -67,13 +63,12 @@ impl DerivedTS {
         quote! {
             #impl_start {
                 #assoc_type
-                const EXPORT_TO: Option<&'static str> = Some(#export_to);
+                #export_to
 
                 fn ident() -> String {
                     #ident.to_owned()
                 }
 
-                #get_export_to
                 #docs
                 #name
                 #decl

ts-rs/src/export.rs

@@ -5,7 +5,7 @@ use std::{
     collections::BTreeMap,
     fmt::Write,
     path::{Component, Path, PathBuf},
-    sync::{Mutex, OnceLock},
+    sync::Mutex,
 };
 
 use thiserror::Error;
@@ -124,30 +124,6 @@ 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() -> Option<&'static str> {
-        static EXPORT_TO: OnceLock<Option<String>> = OnceLock::new();
-        EXPORT_TO
-            .get_or_init(|| std::env::var(EXPORT_DIR_ENV_VAR).ok())
-            .as_deref()
-    }
-
-    /// 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().map_or_else(
-            || T::EXPORT_TO.map(ToString::to_string),
-            |path| Some(format!("{path}/{}.ts", T::ident())),
-        )
-    }
-}
-
 /// 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);
@@ -159,10 +135,19 @@ pub(crate) fn export_type_to_string<T: TS + ?Sized + 'static>() -> Result<String
 
 /// Compute the output path to where `T` should be exported.
 fn output_path<T: TS + ?Sized>() -> Result<PathBuf, ExportError> {
+    let path = std::env::var("TS_RS_EXPORT_DIR")
+        .ok()
+        .as_deref()
+        .map(Path::new)
+        .unwrap_or_else(|| Path::new("."))
+        .to_owned();
+
     path::absolute(Path::new(
-        &T::get_export_to()
-            .ok_or_else(|| std::any::type_name::<T>())
-            .map_err(ExportError::CannotBeExported)?,
+        &path.join(
+            T::EXPORT_TO
+                .ok_or_else(|| std::any::type_name::<T>())
+                .map_err(ExportError::CannotBeExported)?,
+        )
     ))
 }
 
@@ -181,9 +166,15 @@ 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 base = std::env::var("TS_RS_EXPORT_DIR")
+        .ok()
+        .as_deref()
+        .map(Path::new)
+        .unwrap_or_else(|| Path::new("."))
+        .to_owned();
     let export_to =
-        T::get_export_to().ok_or(ExportError::CannotBeExported(std::any::type_name::<T>()))?;
-    let path = Path::new(&export_to);
+        T::EXPORT_TO.ok_or(ExportError::CannotBeExported(std::any::type_name::<T>()))?;
+    let path = base.join(export_to);
 
     let deps = T::dependencies();
     let deduplicated_deps = deps
@@ -193,7 +184,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

@@ -165,9 +165,6 @@ use std::{
 pub use ts_rs_macros::TS;
 
 pub use crate::export::ExportError;
-// Used in generated code. Not public API
-#[doc(hidden)]
-pub use crate::export::__private;
 use crate::typelist::TypeList;
 
 #[cfg(feature = "chrono-impl")]
@@ -304,10 +301,6 @@ pub trait TS {
         }
     }
 
-    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.
     ///
@@ -428,7 +421,17 @@ impl Dependency {
     /// 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::get_export_to()?;
+        let base = std::env::var("TS_RS_EXPORT_DIR")
+            .ok()
+            .as_deref()
+            .map(Path::new)
+            .unwrap_or_else(|| Path::new("."))
+            .to_owned();
+
+        let exported_to = base
+            .join(T::EXPORT_TO.map(ToOwned::to_owned)?)
+            .to_string_lossy()
+            .to_string();
         Some(Dependency {
             type_id: TypeId::of::<T>(),
             ts_name: T::ident(),

ts-rs/tests/docs.rs

@@ -1,9 +1,10 @@
 #![allow(dead_code)]
 
-use std::{concat, fs};
+use std::{concat, fs, path::PathBuf};
 
 use ts_rs::TS;
 
+
 /* ============================================================================================== */
 
 /// Doc comment.
@@ -95,6 +96,13 @@ struct G {
 
 /* ============================================================================================== */
 
+fn generate_path(path: &str) -> PathBuf {
+    std::env::current_dir().unwrap()
+        .join(std::env::var("TS_RS_EXPORT_DIR").unwrap_or_default())
+        .join("tests-out/docs/")
+        .join(path)
+}
+
 #[test]
 fn export_a() {
     A::export().unwrap();
@@ -136,7 +144,14 @@ fn export_a() {
         )
     };
 
-    let actual_content = fs::read_to_string("tests-out/docs/A.ts").unwrap();
+    let Ok(actual_content) = fs::read_to_string(generate_path("A.ts")) else {
+        panic!(
+            "failed to read path: {}\ncurrent dir: {}\nTS_RS_EXPORT_DIR: {}",
+            generate_path("A.ts").to_string_lossy(),
+            std::env::current_dir().unwrap().to_string_lossy(),
+            std::env::var("TS_RS_EXPORT_DIR").unwrap_or_default()
+        )
+    };
 
     assert_eq!(actual_content, expected_content);
 }
@@ -182,7 +197,7 @@ fn export_b() {
         )
     };
 
-    let actual_content = fs::read_to_string("tests-out/docs/B.ts").unwrap();
+    let actual_content = fs::read_to_string(generate_path("B.ts")).unwrap();
 
     assert_eq!(actual_content, expected_content);
 }
@@ -215,7 +230,7 @@ fn export_c() {
         )
     };
 
-    let actual_content = fs::read_to_string("tests-out/docs/C.ts").unwrap();
+    let actual_content = fs::read_to_string(generate_path("C.ts")).unwrap();
 
     assert_eq!(actual_content, expected_content);
 }
@@ -247,7 +262,7 @@ fn export_d() {
             "export type D = null;"
         )
     };
-    let actual_content = fs::read_to_string("tests-out/docs/D.ts").unwrap();
+    let actual_content = fs::read_to_string(generate_path("D.ts")).unwrap();
 
     assert_eq!(actual_content, expected_content);
 }
@@ -280,7 +295,7 @@ fn export_e() {
         )
     };
 
-    let actual_content = fs::read_to_string("tests-out/docs/E.ts").unwrap();
+    let actual_content = fs::read_to_string(generate_path("E.ts")).unwrap();
 
     assert_eq!(actual_content, expected_content);
 }
@@ -328,7 +343,7 @@ fn export_f() {
         )
     };
 
-    let actual_content = fs::read_to_string("tests-out/docs/F.ts").unwrap();
+    let actual_content = fs::read_to_string(generate_path("F.ts")).unwrap();
 
     assert_eq!(actual_content, expected_content);
 }
@@ -376,7 +391,7 @@ fn export_g() {
         )
     };
 
-    let actual_content = fs::read_to_string("tests-out/docs/G.ts").unwrap();
+    let actual_content = fs::read_to_string(generate_path("G.ts")).unwrap();
 
     assert_eq!(actual_content, expected_content);
 }

ts-rs/tests/export_manually.rs

@@ -36,7 +36,12 @@ fn export_manually() {
         )
     };
 
-    let actual_content = fs::read_to_string("tests-out/export_manually/UserFile.ts").unwrap();
+    let actual_content = fs::read_to_string(
+        match std::env::var("TS_RS_EXPORT_DIR") {
+            Ok(path) => format!("{}/tests-out/export_manually/UserFile.ts", path.trim_end_matches('/')),
+            Err(_) => "tests-out/export_manually/UserFile.ts".to_owned(),
+        }
+    ).unwrap();
 
     assert_eq!(actual_content, expected_content);
 }
@@ -57,7 +62,12 @@ fn export_manually_dir() {
         )
     };
 
-    let actual_content = fs::read_to_string("tests-out/export_manually/dir/UserDir.ts").unwrap();
+    let actual_content = fs::read_to_string(
+        match std::env::var("TS_RS_EXPORT_DIR") {
+            Ok(path) => format!("{}/tests-out/export_manually/dir/UserDir.ts", path.trim_end_matches('/')),
+            Err(_) => "tests-out/export_manually/dir/UserDir.ts".to_owned(),
+        }
+    ).unwrap();
 
     assert_eq!(actual_content, expected_content);
 }

ts-rs/tests/imports.rs

@@ -1,4 +1,6 @@
 #![allow(dead_code)]
+use std::path::Path;
+
 use ts_rs::TS;
 
 #[derive(TS)]
@@ -25,7 +27,14 @@ pub enum TestEnum {
 fn test_def() {
     // The only way to get access to how the imports look is to export the type and load the exported file
     TestEnum::export().unwrap();
-    let text = std::fs::read_to_string(TestEnum::EXPORT_TO.unwrap()).unwrap();
+    let path = std::env::var("TS_RS_EXPORT_DIR")
+        .ok()
+        .as_deref()
+        .map(Path::new)
+        .unwrap_or_else(|| Path::new("."))
+        .to_owned()
+        .join(TestEnum::EXPORT_TO.unwrap());
+    let text = std::fs::read_to_string(&path).unwrap();
 
     let expected = match (cfg!(feature = "format"), cfg!(feature = "import-esm")) {
         (true, true) => concat!(
@@ -65,5 +74,5 @@ fn test_def() {
     };
 
     assert_eq!(text, expected);
-    std::fs::remove_file(TestEnum::EXPORT_TO.unwrap()).unwrap();
+    std::fs::remove_file(path).unwrap();
 }

ts-rs/tests/path_bug.rs

@@ -15,10 +15,11 @@ struct Bar {
 
 #[test]
 fn path_bug() {
-    Foo::export().unwrap();
-    Bar::export().unwrap();
+    export_bindings_foo();
 
-    let base = std::env::current_dir().unwrap();
-    assert!(base.join("./tests-out/path_bug/Foo.ts").is_file());
-    assert!(base.join("./tests-out/path_bug/aaa/Bar.ts").is_file());
-}
+    let base = std::env::current_dir()
+        .unwrap()
+        .join(std::env::var("TS_RS_EXPORT_DIR").unwrap_or("".to_owned()));
+    assert!(base.join("../ts-rs/tests-out/path_bug/Foo.ts").is_file());
+    assert!(base.join("tests-out/path_bug/aaa/Bar.ts").is_file());
+}