specta-typescript 0.0.11

Export your Rust types to TypeScript
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use specta::{ResolvedTypes, Type, Types};
use specta_typescript::{Any, Layout, Typescript, primitives};

#[derive(Type)]
pub struct Testing {
    field: Any,
}

mod nested {
    #[derive(specta::Type)]
    pub struct Another {
        field: super::Testing,
        field2: super::another::Bruh,
    }
}

mod another {
    #[derive(specta::Type)]
    pub struct Bruh {
        field: u32,
        field2: bruh::Testing,
    }

    mod bruh {
        #[derive(specta::Type)]
        pub struct Testing {
            field: dev::Testing,
        }

        mod dev {
            #[derive(specta::Type)]
            pub struct Testing {
                field: u32,
            }
        }
    }
}

// /// An IPC channel.
// pub struct Channel<TSend> {
//     phantom: std::marker::PhantomData<TSend>,
// }

// const _: () = {
//     #[derive(specta::Type)]
//     #[specta(remote = Channel, rename = "TAURI_CHANNEL")]
//     #[allow(dead_code)]
//     struct Channel2<TSend>(std::marker::PhantomData<TSend>);
// };

fn main() {
    let ts = Typescript::default();

    // let r = ts.define("string & { _brand: 'a' }");
    // println!(
    //     "{:?}",
    //     primitives::inline(&ts, &Default::default(), &r.into())
    // );

    // TODO: Properly handle this with opaque types
    // println!("{:?}", primitives::inline(&Default::default(), &Default::default(), &DataType::String));

    ts.layout(Layout::Namespaces)
        .export_to(
            "demo.ts",
            &ResolvedTypes::from_resolved_types(Types::default().register::<nested::Another>()),
        )
        .unwrap();

    // println!("PTR EQ: {:?}", std::ptr::eq(&ANY, &ANY));

    // println!(
    //     "definition: {:?}",
    //     Reference::opaque2(&ANY).ref_eq(&Reference::opaque2(&ANY))
    // );

    // match (
    //     Any::<()>::definition(&mut Default::default()),
    //     Any::<()>::definition(&mut Default::default()),
    // ) {
    //     (DataType::Reference(ref1), DataType::Reference(ref2)) => {
    //         println!(
    //             "Reference Tokens: {:?}, {:?} {:?}",
    //             ref1,
    //             ref2,
    //             ref1.ref_eq(&ref2)
    //         );
    //     }
    //     _ => {
    //         println!("Unexpected data types");
    //     }
    // }

    // println!(
    //     "{:?}",
    //     primitives::inline(
    //         &ts,
    //         &Default::default(),
    //         &Any::<()>::definition(&mut Default::default())
    //     )
    // )
}