ts-rs-macros 12.0.0

derive macro for ts-rs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

use quote::quote;
use syn::{Expr, FieldsUnnamed, Result};

use crate::{
    attr::{Attr, ContainerAttr, FieldAttr, StructAttr},
    deps::Dependencies,
    DerivedTS,
};

pub(crate) fn newtype(
    attr: &StructAttr,
    ts_name: Expr,
    fields: &FieldsUnnamed,
) -> Result<DerivedTS> {
    let inner = fields.unnamed.first().unwrap();

    let field_attr = FieldAttr::from_attrs(&inner.attrs)?;
    field_attr.assert_validity(inner)?;

    let crate_rename = attr.crate_rename();

    if field_attr.skip {
        return Ok(super::unit::null(attr, ts_name));
    }

    let inner_ty = field_attr.type_as(&inner.ty);

    let mut dependencies = Dependencies::new(crate_rename.clone());

    match (&field_attr.type_override, field_attr.inline) {
        (Some(_), _) => (),
        (None, true) => dependencies.append_from(&inner_ty),
        (None, false) => dependencies.push(&inner_ty),
    };

    let inline_def = match field_attr.type_override {
        Some(ref o) => quote!(#o.to_owned()),
        None if field_attr.inline => quote!(<#inner_ty as #crate_rename::TS>::inline(cfg)),
        None => quote!(<#inner_ty as #crate_rename::TS>::name(cfg)),
    };

    Ok(DerivedTS {
        crate_rename: crate_rename.clone(),
        inline: inline_def,
        inline_flattened: None,
        docs: attr.docs.clone(),
        dependencies,
        export: attr.export,
        export_to: attr.export_to.clone(),
        ts_name,
        concrete: attr.concrete.clone(),
        bound: attr.bound.clone(),
        ts_enum: None,
        is_enum: if field_attr.type_override.is_none() {
            quote!(<#inner_ty as #crate_rename::TS>::IS_ENUM)
        } else {
            quote!(false)
        },
    })
}