add support for fast_immutable_collections types including ListMap, ListSet, and IMapOfSets

Author: jperezrealini

builders/json_serializable_fic/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.1.4
+
+- **FEAT**: Add support for `fast_immutable_collections` `ListMap`, `ListSet` and `IMapOfSets` types.
+
 ## 1.1.3
 
 - **CHORE**: Update `fast_immutable_collections` to ^11.1.0

builders/json_serializable_fic/lib/builder.dart

@@ -18,6 +18,9 @@ Builder jsonSerializable(BuilderOptions options) {
         FICIListTypeHelper(),
         FICISetTypeHelper(),
         FICIMapTypeHelper(),
+        FICListSetTypeHelper(),
+        FICListMapTypeHelper(),
+        FICIMapOfSetsTypeHelper(),
       ], config: config),
       const JsonLiteralGenerator(),
     ], 'json_serializable');

builders/json_serializable_fic/lib/type_helpers.dart

@@ -1,2 +1,8 @@
 export 'package:json_serializable_fic_typehelpers/json_serializable_fic_typehelpers.dart'
-    show FICIListTypeHelper, FICIMapTypeHelper, FICISetTypeHelper;
+    show
+        FICIListTypeHelper,
+        FICIMapTypeHelper,
+        FICISetTypeHelper,
+        FICListSetTypeHelper,
+        FICListMapTypeHelper,
+        FICIMapOfSetsTypeHelper;

builders/json_serializable_fic/pubspec.yaml

@@ -1,6 +1,6 @@
 name: json_serializable_fic
 description: Adding support for fast immutable collections for json_serializable
-version: 1.1.3
+version: 1.1.4
 homepage: https://github.com/knaeckeKami/immutable_json_list_serializer
 
 environment:
@@ -21,4 +21,4 @@ dependencies:
   source_gen: ^4.2.0
   analyzer: ^10.0.1
   build: ^4.0.4
-  json_serializable_fic_typehelpers: ^2.2.1
+  json_serializable_fic_typehelpers: ^2.2.3

builders/json_serializable_fic/test/integration/model.dart

@@ -24,6 +24,9 @@ class MyModel {
     required this.nullableMap,
     required this.nullableSet,
     required this.enumMap,
+    required this.myListSet,
+    required this.myListMap,
+    required this.myMapOfSets,
   });
 
   final IList<int> myList;
@@ -60,14 +63,20 @@ class MyModel {
 
   final IMap<MyEnum, String> enumMap;
 
+  final ListSet<String> myListSet;
+
+  final ListMap<String, int> myListMap;
+
+  final IMapOfSets<String, int> myMapOfSets;
+
   factory MyModel.fromJson(Map<String, dynamic> json) =>
       _$MyModelFromJson(json);
 
   Map<String, dynamic> toJson() => _$MyModelToJson(this);
 
   @override
   String toString() {
-    return 'MyModel{myList: $myList, myString: $myString, myNested: $myNested, normalList: $normalList, normalSet: $normalSet, builtMap: $builtMap, builtMapString: $builtMapString, builtMapNested: $builtMapNested, nullList: $nullList, listWithNullable: $listWithNullable, nullablelistWithNullable: $nullablelistWithNullable, nullSet: $nullSet, nullableSet: $nullableSet, nullMap: $nullMap, nullableMap: $nullableMap, dynamicMap: $dynamicMap, enumMap: $enumMap}';
+    return 'MyModel{myList: $myList, myString: $myString, myNested: $myNested, normalList: $normalList, normalSet: $normalSet, builtMap: $builtMap, builtMapString: $builtMapString, builtMapNested: $builtMapNested, nullList: $nullList, listWithNullable: $listWithNullable, nullablelistWithNullable: $nullablelistWithNullable, nullSet: $nullSet, nullableSet: $nullableSet, nullMap: $nullMap, nullableMap: $nullableMap, dynamicMap: $dynamicMap, enumMap: $enumMap, myListSet: $myListSet, myListMap: $myListMap, myMapOfSets: $myMapOfSets}';
   }
 
   @override
@@ -91,26 +100,35 @@ class MyModel {
           nullMap == other.nullMap &&
           nullableMap == other.nullableMap &&
           dynamicMap == other.dynamicMap &&
-          enumMap == other.enumMap;
+          enumMap == other.enumMap &&
+          DeepCollectionEquality().equals(myListSet, other.myListSet) &&
+          DeepCollectionEquality().equals(myListMap, other.myListMap) &&
+          myMapOfSets == other.myMapOfSets;
 
   @override
-  int get hashCode =>
-      myList.hashCode ^
-      myString.hashCode ^
-      myNested.hashCode ^
-      normalList.hashCode ^
-      normalSet.hashCode ^
-      builtMap.hashCode ^
-      builtMapString.hashCode ^
-      builtMapNested.hashCode ^
-      nullList.hashCode ^
-      listWithNullable.hashCode ^
-      nullablelistWithNullable.hashCode ^
-      nullSet.hashCode ^
-      nullableSet.hashCode ^
-      nullMap.hashCode ^
-      nullableMap.hashCode ^
-      dynamicMap.hashCode;
+  int get hashCode {
+    final deepEquality = DeepCollectionEquality();
+    return myList.hashCode ^
+        myString.hashCode ^
+        myNested.hashCode ^
+        deepEquality.hash(normalList) ^
+        deepEquality.hash(normalSet) ^
+        builtMap.hashCode ^
+        builtMapString.hashCode ^
+        builtMapNested.hashCode ^
+        nullList.hashCode ^
+        listWithNullable.hashCode ^
+        nullablelistWithNullable.hashCode ^
+        nullSet.hashCode ^
+        nullableSet.hashCode ^
+        nullMap.hashCode ^
+        nullableMap.hashCode ^
+        dynamicMap.hashCode ^
+        enumMap.hashCode ^
+        deepEquality.hash(myListSet) ^
+        deepEquality.hash(myListMap) ^
+        myMapOfSets.hashCode;
+  }
 }
 
 @JsonSerializable()

builders/json_serializable_fic/test/integration/model.g.dart

@@ -23,6 +23,12 @@ final model = MyModel(
   nullableMap: {"a": null}.toIMap(),
   nullableSet: {"", null}.toISet(),
   enumMap: IMap<MyEnum, String>({MyEnum.one: "1", MyEnum.two: "2"}),
+  myListSet: ListSet.of(["x", "y", "z"]),
+  myListMap: ListMap.of({"key1": 10, "key2": 20}),
+  myMapOfSets: IMapOfSets<String, int>({
+    "set1": {1, 2, 3},
+    "set2": {4, 5},
+  }),
 );
 
 const jsonMapExpected = {
@@ -47,6 +53,12 @@ const jsonMapExpected = {
   "nullableMap": {"a": null},
   "nullableSet": ["", null],
   "enumMap": {"one": "1", "two": "2"},
+  "myListSet": ["x", "y", "z"],
+  "myListMap": {"key1": 10, "key2": 20},
+  "myMapOfSets": {
+    "set1": [1, 2, 3],
+    "set2": [4, 5],
+  },
 };
 
 void main() {

builders/json_serializable_fic/test/integration/model_test.dart

@@ -1,3 +1,7 @@
+## 2.2.3
+
+- **FEAT**: Add support for `fast_immutable_collections` `ListMap`, `ListSet` and `IMapOfSets` types.
+
 ## 2.2.2
 
 - **CHORE**: Update `fast_immutable_collections` to ^11.1.0

typehelpers/json_serializable_fic_typehelpers/CHANGELOG.md

@@ -1,2 +1,8 @@
 export 'src/fic_type_helpers.dart'
-    show FICIMapTypeHelper, FICIListTypeHelper, FICISetTypeHelper;
+    show
+        FICIMapTypeHelper,
+        FICIListTypeHelper,
+        FICISetTypeHelper,
+        FICListSetTypeHelper,
+        FICListMapTypeHelper,
+        FICIMapOfSetsTypeHelper;

typehelpers/json_serializable_fic_typehelpers/lib/json_serializable_fic_typehelpers.dart

@@ -5,7 +5,11 @@
 import 'package:analyzer/dart/element/type.dart';
 import 'package:fast_immutable_collections/fast_immutable_collections.dart';
 import 'package:json_serializable_type_helper_utils/json_serializable_type_helper_utils.dart';
+import 'package:json_serializable/type_helper.dart';
+// ignore: implementation_imports
+import 'package:json_serializable/src/constants.dart';
 import 'package:source_gen/source_gen.dart' show TypeChecker;
+import 'package:source_helper/source_helper.dart';
 
 class FICIListTypeHelper extends CustomIterableTypeHelper<IList> {
   @override
@@ -86,3 +90,165 @@ class FICIMapTypeHelper extends CustomMapTypeHelper<IMap> {
     return '$mapExpression$optionalQuestion.unlockLazy';
   }
 }
+
+class FICListSetTypeHelper extends CustomIterableTypeHelper<ListSet> {
+  @override
+  TypeChecker get typeChecker => const TypeChecker.typeNamed(
+    ListSet,
+    inPackage: 'fast_immutable_collections',
+  );
+
+  @override
+  String deserializeFromIterableExpression(
+    String expression,
+    DartType resolvedGenericType,
+  ) {
+    // Convert to List first to ensure consistent ordering and equality
+    return 'ListSet.of(($expression).toList())';
+  }
+
+  @override
+  String serializeToList(
+    String expression,
+    DartType resolvedGenericType,
+    bool isExpressionNullable,
+  ) {
+    // not needed as ListSet implements Iterable
+    throw UnimplementedError();
+  }
+}
+
+class FICListMapTypeHelper extends CustomMapTypeHelper<ListMap> {
+  @override
+  TypeChecker get typeChecker => const TypeChecker.typeNamed(
+    ListMap,
+    inPackage: 'fast_immutable_collections',
+  );
+
+  @override
+  String deserializeFromMapExpression(
+    String mapExpression,
+    DartType keyType,
+    DartType valueType,
+  ) {
+    return 'ListMap.of($mapExpression)';
+  }
+
+  @override
+  String serializeToMapExpression(
+    String mapExpression,
+    DartType keyType,
+    DartType valueType,
+    bool isMapExpressionNullable,
+  ) {
+    // ListMap implements Map directly, so we can use it as-is
+    // No conversion needed since ListMap is already a Map
+    return mapExpression;
+  }
+}
+
+class FICIMapOfSetsTypeHelper extends TypeHelper<TypeHelperContextWithConfig> {
+  @override
+  final TypeChecker typeChecker = const TypeChecker.typeNamed(
+    IMapOfSets,
+    inPackage: 'fast_immutable_collections',
+  );
+
+  DartType _getKeyType(DartType type) =>
+      type.typeArgumentsOf(typeChecker)!.first;
+
+  DartType _getValueType(DartType type) {
+    // IMapOfSets<K, V> is Map<K, Set<V>>
+    // The type arguments are [K, V] where V is the element type of the sets
+    // So we can directly return the second type argument
+    return type.typeArgumentsOf(typeChecker)!.last;
+  }
+
+  @override
+  Object? serialize(
+    DartType targetType,
+    String expression,
+    TypeHelperContext context,
+  ) {
+    if (!typeChecker.isAssignableFromType(targetType)) {
+      return null;
+    }
+
+    final keyType = _getKeyType(targetType);
+    final valueType = _getValueType(targetType);
+    final targetTypeIsNullable = targetType.isNullableType;
+    final optionalQuestion = targetTypeIsNullable ? '?' : '';
+
+    // Serialize each Set<V> value to List<V>
+    final subFieldValue = context.serialize(valueType, closureArg);
+    final subKeyValue = forType(keyType)?.serialize(keyType, keyParam, false) ??
+        context.serialize(keyType, keyParam);
+
+    if (closureArg == subFieldValue && keyParam == subKeyValue) {
+      // Simple case: just convert Set<V> to List<V>
+      return '$expression$optionalQuestion.unlock.map(($keyParam, v) => MapEntry($subKeyValue, v.toList()))';
+    }
+
+    // Complex case: need to serialize individual values
+    return '$expression$optionalQuestion.unlock.map(($keyParam, v) => MapEntry($subKeyValue, (v as Set<${valueType.getDisplayString()}>).map((e) => $subFieldValue).toList()))';
+  }
+
+  @override
+  Object? deserialize(
+    DartType targetType,
+    String expression,
+    TypeHelperContextWithConfig context,
+    bool defaultProvided,
+  ) {
+    if (!typeChecker.isExactlyType(targetType)) {
+      return null;
+    }
+
+    final keyType = _getKeyType(targetType);
+    final valueType = _getValueType(targetType);
+    final targetTypeIsNullable = targetType.isNullableType || defaultProvided;
+    final optionalQuestion = targetTypeIsNullable ? '?' : '';
+
+    checkSafeKeyType(expression, keyType);
+
+    final itemSubValObj = context.deserialize(valueType, closureArg);
+    final itemSubVal = itemSubValObj.toString();
+    final mapCast = context.config.anyMap ? 'as Map' : 'as Map<String, dynamic>';
+
+    String keyUsage;
+    if (keyType.isEnum) {
+      keyUsage = context.deserialize(keyType, keyParam).toString();
+    } else if (context.config.anyMap &&
+        !(keyType.isDartCoreObject || keyType is DynamicType)) {
+      keyUsage = '$keyParam as String';
+    } else if (context.config.anyMap &&
+        keyType.isDartCoreObject &&
+        !keyType.isNullableType) {
+      keyUsage = '$keyParam as Object';
+    } else {
+      keyUsage = keyParam;
+    }
+
+    final toFromString = forType(keyType);
+    if (toFromString != null) {
+      keyUsage = toFromString
+          .deserialize(keyType, keyUsage, false, true)
+          .toString();
+    }
+
+    // Convert Map<K, List<V>> to Map<K, Set<V>>, then use .lock
+    if (closureArg == itemSubValObj) {
+      return wrapNullableIfNecessary(
+        expression,
+        '(($expression $mapCast).map(($keyParam, v) => MapEntry($keyUsage, Set<${valueType.getDisplayString()}>.from(v as List)))).lock',
+        targetTypeIsNullable,
+      );
+    }
+
+    return wrapNullableIfNecessary(
+      expression,
+      '(($expression $mapCast).map(($keyParam, v) => MapEntry($keyUsage, Set<${valueType.getDisplayString()}>.from((v as List).map((e) => $itemSubVal))))).lock',
+      targetTypeIsNullable,
+    );
+  }
+}