specta_typescript/
types.rs

1use std::fmt::Debug;
2
3use specta::{
4    Type, TypeCollection,
5    datatype::{DataType, Reference},
6};
7
8use crate::opaque;
9
10/// Cast a Rust type to a Typescript `any` type.
11///
12/// WARNING: When used with `Option<Any<T>>`, Typescript will not prompt you about nullability checks as `any | null` is coalesced to `any` in Typescript.
13///
14/// # Examples
15///
16/// This can be used as a type override.
17/// ```rust
18/// use serde::Serialize;
19/// use specta::Type;
20/// use specta_typescript::Any;
21///
22/// #[derive(Serialize, Type)]
23/// pub struct Demo {
24///     #[specta(type = Any)]
25///     pub field: String,
26/// }
27/// ```
28///
29/// Or it can be used as a wrapper type.
30/// ```rust
31/// use serde::Serialize;
32/// use specta::Type;
33/// use specta_typescript::Any;
34///
35/// # #[cfg(feature = "serde")] {
36/// #[derive(Serialize, Type)]
37/// pub struct Demo {
38///     pub field: Any<String>,
39/// }
40/// # }
41/// ```
42pub struct Any<T = ()>(T);
43
44impl<T> Type for Any<T> {
45    fn definition(_: &mut TypeCollection) -> DataType {
46        DataType::Reference(Reference::opaque(opaque::Any))
47    }
48}
49
50impl<T: Debug> Debug for Any<T> {
51    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
52        f.debug_tuple("Any").field(&self.0).finish()
53    }
54}
55
56impl<T: Clone> Clone for Any<T> {
57    fn clone(&self) -> Self {
58        Self(self.0.clone())
59    }
60}
61
62impl<T: Default> Default for Any<T> {
63    fn default() -> Self {
64        Self(T::default())
65    }
66}
67
68#[cfg(feature = "serde")]
69#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
70impl<T: serde::Serialize> serde::Serialize for Any<T> {
71    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
72    where
73        S: serde::Serializer,
74    {
75        T::serialize(&self.0, serializer)
76    }
77}
78
79/// Cast a Rust type to a Typescript `unknown` type.
80///
81/// # Examples
82///
83/// This can be used as a type override.
84/// ```rust
85/// use serde::Serialize;
86/// use specta::Type;
87/// use specta_typescript::Unknown;
88///
89/// #[derive(Serialize, Type)]
90/// pub struct Demo {
91///     #[specta(type = Unknown)]
92///     pub field: String,
93/// }
94/// ```
95///
96/// Or it can be used as a wrapper type.
97/// ```rust
98/// use serde::Serialize;
99/// use specta::Type;
100/// use specta_typescript::Unknown;
101///
102/// # #[cfg(feature = "serde")] {
103/// #[derive(Serialize, Type)]
104/// pub struct Demo {
105///     pub field: Unknown<String>,
106/// }
107/// # }
108/// ```
109pub struct Unknown<T = ()>(T);
110
111impl<T> Type for Unknown<T> {
112    fn definition(_: &mut TypeCollection) -> DataType {
113        DataType::Reference(Reference::opaque(opaque::Unknown))
114    }
115}
116
117impl<T: Debug> Debug for Unknown<T> {
118    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
119        f.debug_tuple("Any").field(&self.0).finish()
120    }
121}
122
123impl<T: Clone> Clone for Unknown<T> {
124    fn clone(&self) -> Self {
125        Self(self.0.clone())
126    }
127}
128
129impl<T: Default> Default for Unknown<T> {
130    fn default() -> Self {
131        Self(T::default())
132    }
133}
134
135#[cfg(feature = "serde")]
136#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
137impl<T: serde::Serialize> serde::Serialize for Unknown<T> {
138    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
139    where
140        S: serde::Serializer,
141    {
142        T::serialize(&self.0, serializer)
143    }
144}
145
146/// Cast a Rust type to a Typescript `never` type.
147///
148/// # Examples
149///
150/// This can be used as a type override.
151/// ```rust
152/// use serde::Serialize;
153/// use specta::Type;
154/// use specta_typescript::Never;
155///
156/// #[derive(Serialize, Type)]
157/// pub struct Demo {
158///     #[specta(type = Never)]
159///     pub field: String,
160/// }
161/// ```
162///
163/// Or it can be used as a wrapper type.
164/// ```rust
165/// use serde::Serialize;
166/// use specta::Type;
167/// use specta_typescript::Never;
168///
169/// # #[cfg(feature = "serde")] {
170/// #[derive(Serialize, Type)]
171/// pub struct Demo {
172///     pub field: Never<String>,
173/// }
174/// # }
175/// ```
176pub struct Never<T = ()>(T);
177
178impl<T> Type for Never<T> {
179    fn definition(_: &mut TypeCollection) -> DataType {
180        DataType::Reference(Reference::opaque(opaque::Never))
181    }
182}
183
184impl<T: Debug> Debug for Never<T> {
185    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
186        f.debug_tuple("Any").field(&self.0).finish()
187    }
188}
189
190impl<T: Clone> Clone for Never<T> {
191    fn clone(&self) -> Self {
192        Self(self.0.clone())
193    }
194}
195
196impl<T: Default> Default for Never<T> {
197    fn default() -> Self {
198        Self(T::default())
199    }
200}
201
202#[cfg(feature = "serde")]
203#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
204impl<T: serde::Serialize> serde::Serialize for Never<T> {
205    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
206    where
207        S: serde::Serializer,
208    {
209        T::serialize(&self.0, serializer)
210    }
211}
specta_typescript/types.rs

specta_typescript/
types.rs
