diff --git a/bindings/java/src/enums.rs b/bindings/java/src/enums.rs
index 8fe65e8ed..e61529d4a 100644
--- a/bindings/java/src/enums.rs
+++ b/bindings/java/src/enums.rs
@@ -1,179 +1,179 @@
+use taffy::AbsoluteAxis;
+use taffy::AlignItems;
+use taffy::AlignContent;
 use taffy::FlexDirection;
+use taffy::FlexWrap;
+use taffy::GridAutoFlow;
 use taffy::TextAlign;
-use taffy::Display;
-use taffy::Position;
+use taffy::Overflow;
 use taffy::BoxSizing;
+use taffy::Position;
 use taffy::BoxGenerationMode;
-use taffy::AlignItems;
-use taffy::AbsoluteAxis;
-use taffy::GridAutoFlow;
-use taffy::FlexWrap;
-use taffy::Overflow;
-use taffy::AlignContent;
+use taffy::Display;
 use crate::traits::FromJavaEnum;
 
-impl FromJavaEnum<AlignContent> for AlignContent {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AlignContent;";
+impl FromJavaEnum<Display> for Display {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Display;";
 
-    fn from_ordinal(internal: i32) -> Option<AlignContent> {
+    fn from_ordinal(internal: i32) -> Option<Display> {
         Some(match internal {
-            0 => AlignContent::Start,
-            1 => AlignContent::End,
-            2 => AlignContent::FlexStart,
-            3 => AlignContent::FlexEnd,
-            4 => AlignContent::Center,
-            5 => AlignContent::Stretch,
-            6 => AlignContent::SpaceBetween,
-            7 => AlignContent::SpaceEvenly,
-            8 => AlignContent::SpaceAround,
-            _ => panic!("Invalid value: {internal}"),
+            0 => Display::Block,
+            1 => Display::Flex,
+            2 => Display::Grid,
+            3 => Display::None,
+            _ => Display::default(),
         })
     }
 }
 
-impl FromJavaEnum<Overflow> for Overflow {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Overflow;";
+impl FromJavaEnum<BoxGenerationMode> for BoxGenerationMode {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/BoxGenerationMode;";
 
-    fn from_ordinal(internal: i32) -> Option<Overflow> {
+    fn from_ordinal(internal: i32) -> Option<BoxGenerationMode> {
         Some(match internal {
-            0 => Overflow::Visible,
-            1 => Overflow::Clip,
-            2 => Overflow::Hidden,
-            3 => Overflow::Scroll,
-            _ => panic!("Invalid value: {internal}"),
+            0 => BoxGenerationMode::Normal,
+            1 => BoxGenerationMode::None,
+            _ => BoxGenerationMode::default(),
         })
     }
 }
 
-impl FromJavaEnum<FlexWrap> for FlexWrap {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/FlexWrap;";
+impl FromJavaEnum<Position> for Position {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Position;";
 
-    fn from_ordinal(internal: i32) -> Option<FlexWrap> {
+    fn from_ordinal(internal: i32) -> Option<Position> {
         Some(match internal {
-            0 => FlexWrap::NoWrap,
-            1 => FlexWrap::Wrap,
-            2 => FlexWrap::WrapReverse,
-            _ => panic!("Invalid value: {internal}"),
+            0 => Position::Relative,
+            1 => Position::Absolute,
+            _ => Position::default(),
         })
     }
 }
 
-impl FromJavaEnum<GridAutoFlow> for GridAutoFlow {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/GridAutoFlow;";
+impl FromJavaEnum<BoxSizing> for BoxSizing {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/BoxSizing;";
 
-    fn from_ordinal(internal: i32) -> Option<GridAutoFlow> {
+    fn from_ordinal(internal: i32) -> Option<BoxSizing> {
         Some(match internal {
-            0 => GridAutoFlow::Row,
-            1 => GridAutoFlow::Column,
-            2 => GridAutoFlow::RowDense,
-            3 => GridAutoFlow::ColumnDense,
-            _ => panic!("Invalid value: {internal}"),
+            0 => BoxSizing::BorderBox,
+            1 => BoxSizing::ContentBox,
+            _ => BoxSizing::default(),
         })
     }
 }
 
-impl FromJavaEnum<AbsoluteAxis> for AbsoluteAxis {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AbsoluteAxis;";
+impl FromJavaEnum<Overflow> for Overflow {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Overflow;";
 
-    fn from_ordinal(internal: i32) -> Option<AbsoluteAxis> {
+    fn from_ordinal(internal: i32) -> Option<Overflow> {
         Some(match internal {
-            0 => AbsoluteAxis::Horizontal,
-            1 => AbsoluteAxis::Vertical,
-            _ => panic!("Invalid value: {internal}"),
+            0 => Overflow::Visible,
+            1 => Overflow::Clip,
+            2 => Overflow::Hidden,
+            3 => Overflow::Scroll,
+            _ => Overflow::default(),
         })
     }
 }
 
-impl FromJavaEnum<AlignItems> for AlignItems {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AlignItems;";
+impl FromJavaEnum<TextAlign> for TextAlign {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/TextAlign;";
 
-    fn from_ordinal(internal: i32) -> Option<AlignItems> {
+    fn from_ordinal(internal: i32) -> Option<TextAlign> {
         Some(match internal {
-            0 => AlignItems::Start,
-            1 => AlignItems::End,
-            2 => AlignItems::FlexStart,
-            3 => AlignItems::FlexEnd,
-            4 => AlignItems::Center,
-            5 => AlignItems::Baseline,
-            6 => AlignItems::Stretch,
-            _ => panic!("Invalid value: {internal}"),
+            0 => TextAlign::Auto,
+            1 => TextAlign::LegacyLeft,
+            2 => TextAlign::LegacyRight,
+            3 => TextAlign::LegacyCenter,
+            _ => TextAlign::default(),
         })
     }
 }
 
-impl FromJavaEnum<BoxGenerationMode> for BoxGenerationMode {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/BoxGenerationMode;";
+impl FromJavaEnum<GridAutoFlow> for GridAutoFlow {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/GridAutoFlow;";
 
-    fn from_ordinal(internal: i32) -> Option<BoxGenerationMode> {
+    fn from_ordinal(internal: i32) -> Option<GridAutoFlow> {
         Some(match internal {
-            0 => BoxGenerationMode::Normal,
-            1 => BoxGenerationMode::None,
-            _ => panic!("Invalid value: {internal}"),
+            0 => GridAutoFlow::Row,
+            1 => GridAutoFlow::Column,
+            2 => GridAutoFlow::RowDense,
+            3 => GridAutoFlow::ColumnDense,
+            _ => GridAutoFlow::default(),
         })
     }
 }
 
-impl FromJavaEnum<BoxSizing> for BoxSizing {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/BoxSizing;";
+impl FromJavaEnum<FlexWrap> for FlexWrap {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/FlexWrap;";
 
-    fn from_ordinal(internal: i32) -> Option<BoxSizing> {
+    fn from_ordinal(internal: i32) -> Option<FlexWrap> {
         Some(match internal {
-            0 => BoxSizing::BorderBox,
-            1 => BoxSizing::ContentBox,
-            _ => panic!("Invalid value: {internal}"),
+            0 => FlexWrap::NoWrap,
+            1 => FlexWrap::Wrap,
+            2 => FlexWrap::WrapReverse,
+            _ => FlexWrap::default(),
         })
     }
 }
 
-impl FromJavaEnum<Position> for Position {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Position;";
+impl FromJavaEnum<FlexDirection> for FlexDirection {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/FlexDirection;";
 
-    fn from_ordinal(internal: i32) -> Option<Position> {
+    fn from_ordinal(internal: i32) -> Option<FlexDirection> {
         Some(match internal {
-            0 => Position::Relative,
-            1 => Position::Absolute,
-            _ => panic!("Invalid value: {internal}"),
+            0 => FlexDirection::Row,
+            1 => FlexDirection::Column,
+            2 => FlexDirection::RowReverse,
+            3 => FlexDirection::ColumnReverse,
+            _ => FlexDirection::default(),
         })
     }
 }
 
-impl FromJavaEnum<Display> for Display {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Display;";
+impl FromJavaEnum<AlignContent> for AlignContent {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AlignContent;";
 
-    fn from_ordinal(internal: i32) -> Option<Display> {
+    fn from_ordinal(internal: i32) -> Option<AlignContent> {
         Some(match internal {
-            0 => Display::Block,
-            1 => Display::Flex,
-            2 => Display::Grid,
-            3 => Display::None,
+            0 => AlignContent::Start,
+            1 => AlignContent::End,
+            2 => AlignContent::FlexStart,
+            3 => AlignContent::FlexEnd,
+            4 => AlignContent::Center,
+            5 => AlignContent::Stretch,
+            6 => AlignContent::SpaceBetween,
+            7 => AlignContent::SpaceEvenly,
+            8 => AlignContent::SpaceAround,
             _ => panic!("Invalid value: {internal}"),
         })
     }
 }
 
-impl FromJavaEnum<TextAlign> for TextAlign {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/TextAlign;";
+impl FromJavaEnum<AlignItems> for AlignItems {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AlignItems;";
 
-    fn from_ordinal(internal: i32) -> Option<TextAlign> {
+    fn from_ordinal(internal: i32) -> Option<AlignItems> {
         Some(match internal {
-            0 => TextAlign::Auto,
-            1 => TextAlign::LegacyLeft,
-            2 => TextAlign::LegacyRight,
-            3 => TextAlign::LegacyCenter,
+            0 => AlignItems::Start,
+            1 => AlignItems::End,
+            2 => AlignItems::FlexStart,
+            3 => AlignItems::FlexEnd,
+            4 => AlignItems::Center,
+            5 => AlignItems::Baseline,
+            6 => AlignItems::Stretch,
             _ => panic!("Invalid value: {internal}"),
         })
     }
 }
 
-impl FromJavaEnum<FlexDirection> for FlexDirection {
-    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/FlexDirection;";
+impl FromJavaEnum<AbsoluteAxis> for AbsoluteAxis {
+    const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AbsoluteAxis;";
 
-    fn from_ordinal(internal: i32) -> Option<FlexDirection> {
+    fn from_ordinal(internal: i32) -> Option<AbsoluteAxis> {
         Some(match internal {
-            0 => FlexDirection::Row,
-            1 => FlexDirection::Column,
-            2 => FlexDirection::RowReverse,
-            3 => FlexDirection::ColumnReverse,
+            0 => AbsoluteAxis::Horizontal,
+            1 => AbsoluteAxis::Vertical,
             _ => panic!("Invalid value: {internal}"),
         })
     }
diff --git a/scripts/genenums/src/generators/java.rs b/scripts/genenums/src/generators/java.rs
index b5f11fa37..d8de2b164 100644
--- a/scripts/genenums/src/generators/java.rs
+++ b/scripts/genenums/src/generators/java.rs
@@ -1,7 +1,6 @@
 use std::fs;
 use std::fs::File;
 use std::io::Write;
-use std::path::Path;
 
 pub(crate) fn create_java_enum(name: &str, values: &[&str]) {
     use convert_case::{Case, Casing};
diff --git a/scripts/genenums/src/main.rs b/scripts/genenums/src/main.rs
index 0a7210278..4e3cd0c55 100644
--- a/scripts/genenums/src/main.rs
+++ b/scripts/genenums/src/main.rs
@@ -1,34 +1,66 @@
-use std::collections::HashMap;
-use std::fs;
 use crate::generators::java::create_java_enum;
 use crate::transformers::java::create_java_tranformer;
+use std::fs;
 
 mod generators;
 mod transformers;
 
+struct RustEnum<'local> {
+    name: &'local str,
+    values: Vec<&'local str>,
+    default: bool,
+}
+
 fn main() {
     fs::remove_file("./bindings/java/src/enums.rs").expect("Error: Unable to remove java/src/enums.rs file");
 
-    let mut enums: HashMap<&str, Vec<&str>> = HashMap::new();
-    enums.insert("Display", vec!["Block", "Flex", "Grid", "None"]);
-    enums.insert("BoxGenerationMode", vec!["Normal", "None"]);
-    enums.insert("Position", vec!["Relative", "Absolute"]);
-    enums.insert("BoxSizing", vec!["BorderBox", "ContentBox"]);
-    enums.insert("Overflow", vec!["Visible", "Clip", "Hidden", "Scroll"]);
-    enums.insert("TextAlign", vec!["Auto", "LegacyLeft", "LegacyRight", "LegacyCenter"]);
-    enums.insert("GridAutoFlow", vec!["Row", "Column", "RowDense", "ColumnDense"]);
-    enums.insert("FlexWrap", vec!["NoWrap", "Wrap", "WrapReverse"]);
-    enums.insert("FlexDirection", vec!["Row", "Column", "RowReverse", "ColumnReverse"]);
-    enums.insert(
-        "AlignContent",
-        vec!["Start", "End", "FlexStart", "FlexEnd", "Center", "Stretch", "SpaceBetween", "SpaceEvenly", "SpaceAround"],
-    );
-    enums.insert("AlignItems", vec!["Start", "End", "FlexStart", "FlexEnd", "Center", "Baseline", "Stretch"]);
-    enums.insert("AbsoluteAxis", vec!["Horizontal", "Vertical"]);
-
-    for (key, value) in enums.into_iter() {
-        create_enum(key, &value);
-        create_transformer(key, &value);
+    let mut enums: Vec<RustEnum> = Vec::new();
+    enums.push(RustEnum { name: "Display", values: vec!["Block", "Flex", "Grid", "None"], default: true });
+    enums.push(RustEnum { name: "BoxGenerationMode", values: vec!["Normal", "None"], default: true });
+    enums.push(RustEnum { name: "Position", values: vec!["Relative", "Absolute"], default: true });
+    enums.push(RustEnum { name: "BoxSizing", values: vec!["BorderBox", "ContentBox"], default: true });
+    enums.push(RustEnum { name: "Overflow", values: vec!["Visible", "Clip", "Hidden", "Scroll"], default: true });
+    enums.push(RustEnum {
+        name: "TextAlign",
+        values: vec!["Auto", "LegacyLeft", "LegacyRight", "LegacyCenter"],
+        default: true,
+    });
+    enums.push(RustEnum {
+        name: "GridAutoFlow",
+        values: vec!["Row", "Column", "RowDense", "ColumnDense"],
+        default: true,
+    });
+    enums.push(RustEnum { name: "FlexWrap", values: vec!["NoWrap", "Wrap", "WrapReverse"], default: true });
+    enums.push(RustEnum {
+        name: "FlexDirection",
+        values: vec!["Row", "Column", "RowReverse", "ColumnReverse"],
+        default: true,
+    });
+    enums.push(RustEnum {
+        name: "AlignContent",
+        values: vec![
+            "Start",
+            "End",
+            "FlexStart",
+            "FlexEnd",
+            "Center",
+            "Stretch",
+            "SpaceBetween",
+            "SpaceEvenly",
+            "SpaceAround",
+        ],
+        default: false,
+    });
+    enums.push(RustEnum {
+        name: "AlignItems",
+        values: vec!["Start", "End", "FlexStart", "FlexEnd", "Center", "Baseline", "Stretch"],
+        default: false,
+    });
+    enums.push(RustEnum { name: "AbsoluteAxis", values: vec!["Horizontal", "Vertical"], default: false });
+
+    for value in enums.into_iter() {
+        create_enum(value.name, &value.values);
+        create_transformer(value.name, &value.values, value.default);
     }
 }
 
@@ -40,8 +72,6 @@ fn create_enum(name: &str, values: &[&str]) {
 
 /// Transformer generators
 
-fn create_transformer(name: &str, values: &[&str]) {
-    create_java_tranformer(name, values);
+fn create_transformer(name: &str, values: &[&str], default: bool) {
+    create_java_tranformer(name, values, default);
 }
-
-
diff --git a/scripts/genenums/src/transformers/java.rs b/scripts/genenums/src/transformers/java.rs
index 19f792db0..9a7533281 100644
--- a/scripts/genenums/src/transformers/java.rs
+++ b/scripts/genenums/src/transformers/java.rs
@@ -1,8 +1,9 @@
 use std::fs;
 use std::fs::File;
+use std::io::Write;
 use std::path::Path;
 
-pub(crate) fn create_java_tranformer(name: &str, values: &[&str]) {
+pub(crate) fn create_java_tranformer(name: &str, values: &[&str], default: bool) {
     let mut file_content: String = "use crate::traits::FromJavaEnum;".to_string();
 
     if Path::new("./bindings/java/src/enums.rs").exists() {
@@ -13,7 +14,11 @@ pub(crate) fn create_java_tranformer(name: &str, values: &[&str]) {
     for (index, value) in values.iter().enumerate() {
         enum_values.push_str(format!("\n            {index} => {name}::{value},").as_str());
     }
-    enum_values.push_str("\n            _ => panic!(\"Invalid value: {internal}\"),");
+    if default {
+        enum_values.push_str(format!("\n            _ => {name}::default(),").as_str());
+    } else {
+        enum_values.push_str("\n            _ => panic!(\"Invalid value: {internal}\"),");
+    }
 
     file_content = format!(
         "use taffy::{name};
@@ -31,4 +36,4 @@ impl FromJavaEnum<{name}> for {name} {{
 
     let file = File::create("./bindings/java/src/enums.rs");
     file.expect("Error: File not found").write_all(file_content.as_ref()).expect("Error: Couldn't write to file");
-}
\ No newline at end of file
+}