support typedef enums marked with @MappableEnum

Author: sikrinick

packages/dart_mappable/test/external_types/external_types_test.dart

@@ -4,6 +4,7 @@ library;
 import 'package:dart_mappable/dart_mappable.dart';
 import 'package:test/test.dart';
 
+import 'other/color.dart' as c;
 import 'other/food.dart' as f;
 import 'other/models.dart' as m;
 import 'other/other.dart' as o;
@@ -22,6 +23,9 @@ typedef Animal = o.Animal;
 @MappableClass()
 typedef Pet = o.Pet;
 
+@MappableEnum()
+typedef Color = c.Color;
+
 @MappableClass()
 class Person with PersonMappable {
   final String firstName;
@@ -36,10 +40,11 @@ void main() {
       expect(Cake('Lemon').toMap(), equals({'type': 'Lemon'}));
       expect(Person('Anna').toMap(), equals({'first_name': 'Anna'}));
       expect(
-        Pet(Person2('Clara'), 'Buddy').toMap(),
+        Pet(Person2('Clara'), 'Buddy', Color.Black).toMap(),
         equals({
           'owner': {'first_name': 'Clara'},
-          'color': 'Buddy',
+          'name': 'Buddy',
+          'color': 'Black',
           'type': 'Pet',
         }),
       );
@@ -49,9 +54,10 @@ void main() {
           AnimalMapper.fromMap({
             'type': 'Pet',
             'owner': {'first_name': 'Clara'},
-            'color': 'Buddy',
+            'name': 'Buddy',
+            'color': 'White',
           }),
-          Pet(Person2('Clara'), 'Buddy'),
+          Pet(Person2('Clara'), 'Buddy', Color.White),
         ),
         isTrue,
       );

packages/dart_mappable/test/external_types/external_types_test.mapper.dart

@@ -0,0 +1,3 @@
+enum Color {
+  Black, Red, White
+}

packages/dart_mappable/test/external_types/other/color.dart

@@ -1,13 +1,15 @@
+import 'color.dart';
 import 'models.dart';
 
 abstract class Animal {
-  final String color;
+  final String name;
+  final Color color;
 
-  const Animal(this.color);
+  const Animal(this.name, this.color);
 }
 
 class Pet extends Animal {
   final Person owner;
 
-  const Pet(this.owner, super.color);
+  const Pet(this.owner, super.name, super.color);
 }

packages/dart_mappable/test/external_types/other/other.dart

@@ -7,7 +7,7 @@ import '../constructor/constructor_mapper_element.dart';
 import '../mapper_element.dart';
 import 'target_class_mapper_element.dart';
 
-/// Element interface for all annotated type aliases.
+/// Element interface for all annotated class type aliases.
 class AliasClassMapperElement extends TargetClassMapperElement {
   AliasClassMapperElement._(
     super.parent,

packages/dart_mappable_builder/lib/src/elements/class/alias_class_mapper_element.dart

@@ -0,0 +1,44 @@
+import 'package:analyzer/dart/element/element.dart';
+import 'package:dart_mappable/dart_mappable.dart';
+
+import '../../builder_options.dart';
+import '../../mapper_group.dart';
+import '../mapper_element.dart';
+import 'target_enum_mapper_element.dart';
+
+/// Element interface for all annotated enum type aliases.
+class AliasEnumMapperElement extends TargetEnumMapperElement {
+  AliasEnumMapperElement._(
+    super.parent,
+    this.alias,
+    super.element,
+    super.options,
+    super.annotation,
+    super.valueNodes,
+  );
+
+  final TypeAliasElement alias;
+
+  static Future<AliasEnumMapperElement> from(
+    MapperElementGroup parent,
+    TypeAliasElement alias,
+    MappableOptions options,
+  ) async {
+    var element = alias.aliasedType.element as EnumElement;
+
+    var annotation = await MapperAnnotation.from<MappableEnum>(alias);
+    var valueNodes = await TargetEnumMapperElement.getValues(element);
+
+    return AliasEnumMapperElement._(
+      parent,
+      alias,
+      element,
+      options,
+      annotation,
+      valueNodes,
+    );
+  }
+
+  @override
+  late final String uniqueClassName = alias.name ?? '';
+}

packages/dart_mappable_builder/lib/src/elements/enum/alias_enum_mapper_element.dart

@@ -10,7 +10,7 @@ import '../mapper_element.dart';
 import 'enum_mapper_element.dart';
 
 class TargetEnumMapperElement extends EnumMapperElement {
-  TargetEnumMapperElement._(
+  TargetEnumMapperElement(
     super.parent,
     super.element,
     super.options,
@@ -24,9 +24,9 @@ class TargetEnumMapperElement extends EnumMapperElement {
     MappableOptions options,
   ) async {
     var annotation = await MapperAnnotation.from<MappableEnum>(element);
-    var valueNodes = await _getValues(element);
+    var valueNodes = await getValues(element);
 
-    return TargetEnumMapperElement._(
+    return TargetEnumMapperElement(
       parent,
       element,
       options,
@@ -73,7 +73,7 @@ class TargetEnumMapperElement extends EnumMapperElement {
         }
       }).toList();
 
-  static Future<List<(FieldElement, AstNode?)>> _getValues(
+  static Future<List<(FieldElement, AstNode?)>> getValues(
     EnumElement element,
   ) async {
     var fields = element.fields.where((f) => f.isEnumConstant).toList();

packages/dart_mappable_builder/lib/src/elements/enum/target_enum_mapper_element.dart

@@ -12,6 +12,7 @@ import 'elements/class/class_mapper_element.dart';
 import 'elements/class/dependent_class_mapper_element.dart';
 import 'elements/class/factory_constructor_mapper_element.dart';
 import 'elements/class/target_class_mapper_element.dart';
+import 'elements/enum/alias_enum_mapper_element.dart';
 import 'elements/enum/dependent_enum_mapper_element.dart';
 import 'elements/enum/target_enum_mapper_element.dart';
 import 'elements/mapper_element.dart';
@@ -125,6 +126,15 @@ class MapperElementGroup {
             await DependentRecordMapperElement.from(this, e, options),
           );
         }
+      } else {
+        print('${enumChecker.hasAnnotationOf(e)}, ${e.aliasedType.toString()}, ${e.aliasedType.element.toString()}');
+        if (enumChecker.hasAnnotationOf(e) && e.aliasedType.element is EnumElement) {
+          if (e.library == library) {
+            return await _addMapper(
+              await AliasEnumMapperElement.from(this, e, options),
+            );
+          }
+        }
       }
     }
     return null;
@@ -410,7 +420,11 @@ class MapperElementGroup {
                   ((e.aliasedType.element is ClassElement &&
                           classChecker.hasAnnotationOf(e)) ||
                       (e.aliasedType is RecordType &&
-                          recordChecker.hasAnnotationOf(e)))));
+                          recordChecker.hasAnnotationOf(e)) ||
+                      (e.aliasedType is EnumElement && enumChecker.hasAnnotationOf(e))
+                  )
+              )
+          );
     }
 
     if (scope == InitializerScope.package ||