Exports your types to other languages, currently supporting TypeScript.
## Install
Add to your `Cargo.toml`
```toml
[dependencies]
burrtype = { version = "0.2", features = ["typescript"] }
```
## Usage
### Preparing your types
Decorate your types with the `Burr` derive macro.
```rust
use burrtype::prelude::*;
#[derive(Burr)]
pub struct Foo(u64);
#[derive(Burr)]
pub struct Bar(Foo);
```
Use the optional `#[burr(mod)]` attribute to assign your type to a module automatically.
```rust
use burrtype::prelude::*;
#[derive(Burr)]
// `Foo` will be automatically included in the specified module if not explicitly included during export
#[burr(mod = "common/types")]
pub struct Foo(u64);
```
### Exporting your types
In your `build.rs` or another binary, we can create an exporter and optionally configure it. The exporter and its components behave as builder patterns.
```rust
Burrxporter::new()
```
Add your types using modules to organize them. This module tree typically translates to the file structure being produced - with one file per module - but language constraits, features, or options can change this behavior.
```rust
.with_mod(BurrMod::new("bar")
.with_type::<Bar>()
)
```
Resolve type dependencies, which exports types your types depend on. They will be added to either the type's chosen module or the given default module. This step is unnecessary if you explicitly include all types needed to describe your data.
```rust
.resolve_exports("common")
```
Export to one or more targets.
```rust
// outputs ./ts/common.ts and ./ts/bar.ts
.export("ts", TypeScript::new())?
// bundles all exported types into a single file
.export("out/bundled.ts", TypeScript::new().with_file_map(ModFileMap::Inline))?
```
See these concepts in action in [the example](examples/sandbox/).
### 3rd-party types
For types that don't derive `Burr`, such as those from third-party crates, use an attribute to treat fields as another type:
```rust
#[derive(serde::Serialize, serde::Deserialize, Debug)]
pub struct PhantomType(pub u64);
#[derive(Burr)]
pub struct Foo {
#[burr(type = u64)]
pub foo: PhantomType,
}
```
Alternatively, you can register a 3rd-party type as a string name representing that type in the target language.
```rust
.export("api", TypeScript::new()
.with_type_name::<rust_decimal::Decimal>("number")
)?
```
---
## Desired features going forward
- Replace panics with errors
- tests
- Rust target
- Support the same set of common features as TypeScript
- Generic types?