Add rename_all support for enum named variants

crates/specta/macros/src/type/attr/variant.rs

@@ -4,6 +4,7 @@ use crate::utils::*;
 
 #[derive(Default)]
 pub struct VariantAttr {
+    pub rename_all: Option<Inflection>,
     pub rename: Option<String>,
     pub skip: bool,
 }
@@ -21,15 +22,24 @@ impl VariantAttr {
         Ok(result)
     }
 
-    fn merge(&mut self, VariantAttr { rename, skip }: VariantAttr) {
+    fn merge(
+        &mut self,
+        VariantAttr {
+            rename,
+            rename_all,
+            skip,
+        }: VariantAttr,
+    ) {
         self.rename = self.rename.take().or(rename);
+        self.rename_all = self.rename_all.take().or(rename_all);
         self.skip = self.skip || skip;
     }
 }
 
 impl_parse! {
     VariantAttr(input, out) {
         "rename" => out.rename = Some(parse_assign_str(input)?),
+        "rename_all" => out.rename_all = Some(parse_assign_inflection(input)?),
         "skip" => out.skip = true,
     }
 }
@@ -38,6 +48,7 @@ impl_parse! {
 impl_parse! {
     SerdeVariantAttr(input, out) {
         "rename" => out.0.rename = Some(parse_assign_str(input)?),
+        "rename_all" => out.0.rename_all = Some(parse_assign_inflection(input)?),
         "skip" => out.0.skip = true,
         "skip_serializing" => out.0.skip = true,
         "skip_deserializing" => out.0.skip = true,

crates/specta/macros/src/type/enum.rs

@@ -139,9 +139,13 @@ pub fn parse_enum(
                             false,
                         );
 
-                        let field_name = field_attrs
-                            .rename
-                            .unwrap_or_else(|| unraw_raw_ident(field.ident.as_ref().unwrap()));
+                        let field_ident_str = unraw_raw_ident(field.ident.as_ref().unwrap());
+
+                        let field_name = match (field_attrs.rename, attrs.rename_all) {
+                            (Some(name), _) => name,
+                            (_, Some(inflection)) => inflection.apply(&field_ident_str),
+                            (_, _) => field_ident_str,
+                        };
 
                         quote!(#crate_ref::ObjectField {
                             name: #field_name.to_string(),

crates/specta/src/enum.rs

@@ -16,31 +16,30 @@ impl EnumType {
         let indexes = self
             .variants
             .iter()
-            .rev()
             .filter(|v| match self.repr {
                 EnumRepr::External => match v {
-                    EnumVariant::Unnamed(v) if v.fields.len() == 1 => true,
-                    EnumVariant::Named(_) => true,
-                    _ => false,
+                    EnumVariant::Unnamed(v) if v.fields.len() == 1 => false,
+                    EnumVariant::Named(_) => false,
+                    _ => true,
                 },
                 EnumRepr::Untagged => match v {
-                    EnumVariant::Unit(_) => true,
-                    EnumVariant::Named(_) => true,
-                    _ => false,
+                    EnumVariant::Unit(_) => false,
+                    EnumVariant::Named(_) => false,
+                    _ => true,
                 },
-                EnumRepr::Adjacent { .. } => true,
+                EnumRepr::Adjacent { .. } => false,
                 EnumRepr::Internal { .. } => match v {
-                    EnumVariant::Unit(_) => true,
-                    EnumVariant::Named(_) => true,
-                    _ => false,
+                    EnumVariant::Unit(_) => false,
+                    EnumVariant::Named(_) => false,
+                    _ => true,
                 },
             })
             .enumerate()
             .map(|(i, _)| i)
             .collect::<Vec<_>>();
 
-        indexes.into_iter().for_each(|i| {
-            self.variants.swap_remove(i);
+        indexes.into_iter().rev().for_each(|i| {
+            self.variants.remove(i);
         });
     }
 }

crates/specta/tests/ts_rs/union.rs

@@ -5,7 +5,10 @@ enum SimpleEnum {
     #[specta(rename = "asdf")]
     A,
     B,
-    C,
+    #[specta(rename_all = "camelCase")]
+    C {
+        enum_field: (),
+    },
 }
 
 #[test]
@@ -20,6 +23,6 @@ fn test_empty() {
 fn test_simple_enum() {
     assert_eq!(
         ts_export::<SimpleEnum>().unwrap(),
-        r#"export type SimpleEnum = "asdf" | "B" | "C""#
+        r#"export type SimpleEnum = "asdf" | "B" | { C: { enumField: null } }"#
     )
 }