fix(compiler): address Copilot code review comments on TypeScript generator

Author: miantalha45

compiler/fory_compiler/generators/typescript.py

@@ -62,12 +62,15 @@ class TypeScriptGenerator(BaseGenerator):
         PrimitiveKind.VAR_UINT64: "bigint | number",
         PrimitiveKind.TAGGED_UINT64: "bigint | number",
         PrimitiveKind.FLOAT16: "number",
+        PrimitiveKind.BFLOAT16: "number",
         PrimitiveKind.FLOAT32: "number",
         PrimitiveKind.FLOAT64: "number",
         PrimitiveKind.STRING: "string",
         PrimitiveKind.BYTES: "Uint8Array",
         PrimitiveKind.DATE: "Date",
         PrimitiveKind.TIMESTAMP: "Date",
+        PrimitiveKind.DURATION: "number",
+        PrimitiveKind.DECIMAL: "number",
         PrimitiveKind.ANY: "any",
     }
 
@@ -108,7 +111,7 @@ def split_imported_types(
                 imported.append(item)
             else:
                 local.append(item)
-        return local, imported  # Return (local, imported) tuple
+        return imported, local  # Return (imported, local) tuple
 
     def get_module_name(self) -> str:
         """Get the TypeScript module name from package."""
@@ -178,7 +181,7 @@ def generate_module(self) -> GeneratedFile:
             lines.append("")
 
         # Generate enums (top-level only)
-        local_enums, _ = self.split_imported_types(self.schema.enums)
+        _, local_enums = self.split_imported_types(self.schema.enums)
         if local_enums:
             lines.append("// Enums")
             lines.append("")
@@ -187,7 +190,7 @@ def generate_module(self) -> GeneratedFile:
                 lines.append("")
 
         # Generate unions (top-level only)
-        local_unions, _ = self.split_imported_types(self.schema.unions)
+        _, local_unions = self.split_imported_types(self.schema.unions)
         if local_unions:
             lines.append("// Unions")
             lines.append("")
@@ -196,7 +199,7 @@ def generate_module(self) -> GeneratedFile:
                 lines.append("")
 
         # Generate messages (including nested types)
-        local_messages, _ = self.split_imported_types(self.schema.messages)
+        _, local_messages = self.split_imported_types(self.schema.messages)
         if local_messages:
             lines.append("// Messages")
             lines.append("")
@@ -244,17 +247,7 @@ def generate_message(
         if comment:
             lines.append(comment)
 
-        # Generate nested enums first
-        for nested_enum in message.nested_enums:
-            lines.extend(self.generate_enum(nested_enum, indent=indent))
-            lines.append("")
-
-        # Generate nested unions
-        for nested_union in message.nested_unions:
-            lines.extend(self.generate_union(nested_union, indent=indent))
-            lines.append("")
-
-        # Generate the main interface
+        # Generate the main interface first
         lines.append(f"{ind}export interface {message.name} {{")
 
         # Generate fields
@@ -266,7 +259,17 @@ def generate_message(
 
         lines.append(f"{ind}}}")
 
-        # Generate nested messages
+        # Generate nested enums after parent interface
+        for nested_enum in message.nested_enums:
+            lines.append("")
+            lines.extend(self.generate_enum(nested_enum, indent=indent))
+
+        # Generate nested unions after parent interface
+        for nested_union in message.nested_unions:
+            lines.append("")
+            lines.extend(self.generate_union(nested_union, indent=indent))
+
+        # Generate nested messages after parent interface
         for nested_msg in message.nested_messages:
             lines.append("")
             lines.extend(
@@ -350,33 +353,25 @@ def generate_registration(self) -> List[str]:
 
         return lines
 
-    def _generate_message_registration(
-        self, message: Message, lines: List[str], parent: Optional[str] = None
-    ):
+    def _generate_message_registration(self, message: Message, lines: List[str]):
         """Generate registration for a message and its nested types."""
-        qual_name = f"{parent}.{message.name}" if parent else message.name
-
-        # Register nested enums
+        # Register nested enums with simple names
         for nested_enum in message.nested_enums:
             if self.should_register_by_id(nested_enum):
                 type_id = nested_enum.type_id
-                lines.append(
-                    f"  fory.register({qual_name}.{nested_enum.name}, {type_id});"
-                )
+                lines.append(f"  fory.register({nested_enum.name}, {type_id});")
 
-        # Register nested unions
+        # Register nested unions with simple names
         for nested_union in message.nested_unions:
             if self.should_register_by_id(nested_union):
                 type_id = nested_union.type_id
-                lines.append(
-                    f"  fory.registerUnion({qual_name}.{nested_union.name}, {type_id});"
-                )
+                lines.append(f"  fory.registerUnion({nested_union.name}, {type_id});")
 
-        # Register nested messages
+        # Register nested messages recursively
         for nested_msg in message.nested_messages:
-            self._generate_message_registration(nested_msg, lines, qual_name)
+            self._generate_message_registration(nested_msg, lines)
 
-        # Register the message itself
+        # Register the message itself with simple name
         if self.should_register_by_id(message):
             type_id = message.type_id
-            lines.append(f"  fory.register({qual_name}, {type_id});")
+            lines.append(f"  fory.register({message.name}, {type_id});")

compiler/fory_compiler/tests/test_typescript_codegen.py

@@ -137,6 +137,30 @@ def test_typescript_nested_enum():
     assert "HOME = 1" in output
 
 
+def test_typescript_nested_enum_registration_uses_simple_name():
+    """Test that nested enums are registered with simple names, not qualified names."""
+    source = dedent(
+        """
+        package example;
+
+        message Person [id=100] {
+            string name = 1;
+
+            enum PhoneType [id=101] {
+                MOBILE = 0;
+                HOME = 1;
+            }
+        }
+        """
+    )
+    output = generate_typescript(source)
+
+    # Check that nested enum is registered with simple name (not qualified name)
+    assert "fory.register(PhoneType, 101)" in output
+    # Ensure qualified names are NOT used
+    assert "Person.PhoneType" not in output
+
+
 def test_typescript_union_generation():
     """Test that unions are properly generated as discriminated unions."""
     source = dedent(
@@ -278,10 +302,14 @@ def test_typescript_field_naming():
     )
     output = generate_typescript(source)
 
-    # Check camelCase conversion
-    assert "first_name:" in output or "firstName:" in output
-    assert "last_name:" in output or "lastName:" in output
-    assert "phone_number:" in output or "phoneNumber:" in output
+    # Check that field names are properly converted to camelCase
+    assert "firstName:" in output
+    assert "lastName:" in output
+    assert "phoneNumber:" in output
+    # Ensure snake_case is not used
+    assert "first_name:" not in output
+    assert "last_name:" not in output
+    assert "phone_number:" not in output
 
 
 def test_typescript_no_runtime_dependencies():