Add a 'quote' attribute to generate quoted TS properties

README.md

@@ -81,6 +81,7 @@ Tsify field attributes
 
 - `type`
 - `optional`
+- `quote`
 
 Serde attributes
 
@@ -141,6 +142,27 @@ export interface Optional {
 }
 ```
 
+## Quoted Properties
+
+`#[tsify(quote)]` puts the resulting TypeScript property in quotes. This can be useful if, for example, `#[serde(rename)]` results in a property that is not a valid identifier in TypeScript.
+
+```rust
+#[derive(Tsify)]
+struct Quoted {
+  #[serde(rename = "with spaces")]
+  #[tsify(quote)]
+  with_spaces: i32
+}
+```
+
+Generated type:
+
+```ts
+export interface Quoted {
+  "with spaces": number;
+}
+```
+
 ## Enum
 
 ```rust

tests/quote.rs

@@ -0,0 +1,34 @@
+#![allow(dead_code)]
+
+use indoc::indoc;
+use pretty_assertions::assert_eq;
+use tsify::Tsify;
+
+#[test]
+fn test_quote() {
+    #[derive(Tsify)]
+    struct QuotedStruct {
+        #[serde(rename = "with spaces")]
+        #[tsify(quote)]
+        with_spaces: i32,
+
+        #[serde(rename = "with-hyphen")]
+        #[tsify(quote)]
+        with_hyphen: i32,
+
+        #[serde(rename = "@invalid!ident")]
+        #[tsify(quote)]
+        invalid_ident: i32,
+    }
+
+    assert_eq!(
+        QuotedStruct::DECL,
+        indoc! { r#"
+            export interface QuotedStruct {
+                "with spaces": number;
+                "with-hyphen": number;
+                "@invalid!ident": number;
+            }"#
+        }
+    );
+}

tsify-macros/src/attrs.rs

@@ -60,13 +60,15 @@ impl TsifyContainerAttars {
 pub struct TsifyFieldAttrs {
     pub type_override: Option<String>,
     pub optional: bool,
+    pub quote: bool,
 }
 
 impl TsifyFieldAttrs {
     pub fn from_serde_field(field: &Field) -> syn::Result<Self> {
         let mut attrs = Self {
             type_override: None,
             optional: false,
+            quote: false,
         };
 
         for attr in &field.original.attrs {
@@ -92,6 +94,14 @@ impl TsifyFieldAttrs {
                     return Ok(());
                 }
 
+                if meta.path.is_ident("quote") {
+                    if attrs.quote {
+                        return Err(meta.error("duplicate attribute"));
+                    }
+                    attrs.quote = true;
+                    return Ok(());
+                }
+
                 Err(meta.error("unsupported tsify attribute, expected one of `type` or `optional`"))
             })?;
         }

tsify-macros/src/parser.rs

@@ -211,10 +211,13 @@ impl<'a> Parser<'a> {
                 let key = field.attrs.name().serialize_name();
                 let (type_ann, field_attrs) = self.parse_field(field);
 
-                let optional = field_attrs.map_or(false, |attrs| attrs.optional);
+                let (optional, quote) =
+                    field_attrs.map_or((false, false), |attrs| (attrs.optional, attrs.quote));
                 let default_is_none = self.container.serde_attrs().default().is_none()
                     && field.attrs.default().is_none();
 
+                let key = if quote { format!("\"{}\"", key) } else { key };
+
                 let type_ann = if optional {
                     match type_ann {
                         TsType::Option(t) => *t,

tsify-macros/src/typescript.rs

@@ -578,14 +578,18 @@ fn is_js_ident(string: &str) -> bool {
     !string.contains('-')
 }
 
+fn is_quoted(string: &str) -> bool {
+    string.starts_with('"') && string.ends_with('"')
+}
+
 impl Display for TsTypeElement {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let key = &self.key;
         let type_ann = &self.type_ann;
 
         let optional_ann = if self.optional { "?" } else { "" };
 
-        if is_js_ident(key) {
+        if is_js_ident(key) || is_quoted(key) {
             write!(f, "{key}{optional_ann}: {type_ann}")
         } else {
             write!(f, "\"{key}\"{optional_ann}: {type_ann}")