Created the new part files: _handler.dart, _deserialization.dart, _serialization.dart, and _utils.dart.

Created the logical handler classes: `Utils`, `TypeInfoHandler`, `SerializationHandler`, and `DeserializationHandler`.

Refactored the `JsonMapper` class to use the new handler classes and removed the obsolete `parts` directory.

Created the new focused utility files: `field_utils.dart`, `validation_utils.dart`, `reflection_utils.dart`, `json_utils.dart`, and `config_utils.dart`.

Created `reflection_handler.dart` and removed the old `reflection_utils.dart` file, centralizing all reflection logic.

Renamed the logic files to `field_inspector.dart`, `constraint_validator.dart`, `json_processor.dart`, and `options_handler.dart` and updated their class names.

Refactored and updated imports in `JsonMapper`, `SerializationHandler`, `DeserializationHandler`, and `TypeInfoHandler` to use the new focused logic files.

Created the barrel file `mapper/lib/mapper.dart` to provide a unified entry point to the library.

Updated all necessary files to use the new `FieldHandler` and `Json` classes, and removed the obsolete imports.

Created all the focused handler files: `reflection_handler.dart`, `field_handler.dart`, `serialization_handler.dart`, `deserialization_handler.dart`, and `type_info_handler.dart`.

Merged the logic from `JsonProcessor` and `OptionsHandler` into the `JsonMap` and `Json` classes, respectively, and removed the old files.

Refactored `JsonMapper` and updated all imports to use the new, consolidated logic handlers.

Created `field_handler.dart` with consolidated field inspection and validation logic, and added a newline.

Created `serialization_handler.dart` and `deserialization_handler.dart` with careful attention to imports and logic.

Refactored `JsonMapper` to use the new, consolidated logic handlers and updated all imports.

The `mapper.dart` file has been split into smaller, more manageable files, and the library is fully functional.

Author: google-labs-jules[bot]

mapper/lib/src/json_map.dart

@@ -1,3 +1,5 @@
+import 'dart:convert' show JsonDecoder;
+
 import 'package:collection/collection.dart' show IterableExtension;
 
 import 'model/index.dart';
@@ -12,6 +14,20 @@ class JsonMap {
 
   JsonMap(this.map, [this.jsonMeta, this.parentMaps]);
 
+  static final JsonDecoder _jsonDecoder = JsonDecoder();
+
+  static bool isValidJSON(dynamic jsonValue) {
+    try {
+      if (jsonValue is String) {
+        _jsonDecoder.convert(jsonValue);
+        return true;
+      }
+      return false;
+    } on FormatException {
+      return false;
+    }
+  }
+
   bool hasProperty(String name) {
     return _isPathExists(_getPath(name));
   }

mapper/lib/src/logic/deserialization_handler.dart

@@ -0,0 +1,332 @@
+import 'dart:convert' show JsonEncoder, JsonDecoder;
+
+import 'package:dart_json_mapper/dart_json_mapper.dart';
+
+import '../class_info.dart';
+import '../errors.dart';
+import '../identifier_casing.dart';
+import '../json_map.dart';
+import '../model/index.dart';
+import 'field_handler.dart';
+import 'reflection_handler.dart';
+
+class DeserializationHandler {
+  final JsonMapper _mapper;
+
+  DeserializationHandler(this._mapper);
+
+  Object? deserializeObject(
+      dynamic jsonValue, DeserializationContext context) {
+    if (jsonValue == null) {
+      return null;
+    }
+    var typeInfo = context.typeInfo!;
+    final converter = _mapper.getConverter(context.jsonPropertyMeta, typeInfo);
+    if (converter != null) {
+      _mapper.configureConverter(converter, context);
+      if (typeInfo.isIterable &&
+          (converter is ICustomIterableConverter &&
+              converter is! DefaultIterableConverter)) {
+        return _mapper.applyValueDecorator(
+            _mapper.getConvertedValue(converter, jsonValue, context), typeInfo);
+      }
+      return _mapper.applyValueDecorator(
+          _mapper.getConvertedValue(converter, jsonValue, context), typeInfo);
+    }
+
+    dynamic convertedJsonValue =
+        JsonMap.isValidJSON(jsonValue) ? JsonDecoder().convert(jsonValue) : jsonValue;
+
+    if (convertedJsonValue is String && typeInfo.type is Type) {
+      return _mapper.typeInfoHandler.getTypeByStringName(convertedJsonValue.replaceAll("\"", ""));
+    }
+
+    final jsonMap = JsonMap(
+        convertedJsonValue, null, context.parentJsonMaps as List<JsonMap>?);
+    typeInfo =
+        _detectObjectType(null, context.typeInfo!.type, jsonMap, context) ??
+            typeInfo;
+    final classInfo = _mapper.classes[typeInfo.type] ??
+        _mapper.classes[typeInfo.genericType] ??
+        _mapper.classes[typeInfo.mixinType];
+    if (classInfo == null) {
+      throw MissingAnnotationOnTypeError(typeInfo.type);
+    }
+    jsonMap.jsonMeta = classInfo.getMeta(context.options.scheme);
+
+    final namedArguments =
+        _getNamedArguments(classInfo, jsonMap, context);
+    final positionalArgumentNames = <String>[];
+    final positionalArguments = _getPositionalArguments(
+        classInfo, jsonMap, context, positionalArgumentNames);
+    dynamic objectInstance;
+    try {
+      objectInstance = context.options.template ??
+          (classInfo.classMirror.isEnum
+              ? null
+              : classInfo.classMirror.newInstance(
+                  classInfo
+                      .getJsonConstructor(context.options.scheme)!
+                      .constructorName,
+                  positionalArguments,
+                  namedArguments));
+    } on TypeError catch (typeError) {
+      final positionalNullArguments = positionalArgumentNames.where((element) =>
+          positionalArguments[positionalArgumentNames.indexOf(element)] ==
+          null);
+      final namedNullArguments = Map<Symbol, dynamic>.from(namedArguments);
+      namedNullArguments.removeWhere((key, value) => value != null);
+      throw CannotCreateInstanceError(
+          typeError, classInfo, positionalNullArguments, namedNullArguments);
+    }
+
+    final im = ReflectionHandler.safeGetInstanceMirror(objectInstance)!;
+    final inheritedPublicFieldNames = classInfo.inheritedPublicFieldNames;
+    final mappedFields = namedArguments.keys
+        .map((Symbol symbol) =>
+            RegExp('"(.+)"').allMatches(symbol.toString()).first.group(1))
+        .toList()
+      ..addAll(positionalArgumentNames);
+
+    _mapper.enumeratePublicProperties(im, jsonMap, context, (name, property,
+        isGetterOnly, JsonProperty? meta, converter, TypeInfo typeInfo) {
+      final propertyContext = context.reBuild(
+          parentObjectInstances: [
+            ...(context.parentObjectInstances ?? []),
+            objectInstance
+          ],
+          typeInfo: typeInfo,
+          jsonPropertyMeta: meta,
+          parentJsonMaps: <JsonMap>[
+            ...(context.parentJsonMaps ?? []),
+            jsonMap
+          ]);
+      final defaultValue = meta?.defaultValue;
+      final hasJsonProperty = jsonMap.hasProperty(property.name);
+      var fieldValue = jsonMap.getPropertyValue(property.name);
+      if (!hasJsonProperty || mappedFields.contains(name)) {
+        if (meta?.flatten == true) {
+          if (mappedFields.contains(name) || isGetterOnly) {
+              return;
+          }
+          final fieldValue = jsonMap.getPropertyValue(property.name);
+          final metaName = meta?.name;
+          final objectToDeserialize = metaName != null && fieldValue is Map
+              ? fieldValue.map((key, value) => MapEntry(skipPrefix(metaName, key, propertyContext.caseStyle), value))
+              : fieldValue;
+
+          im.invokeSetter(name, this.deserializeObject(objectToDeserialize, propertyContext));
+          return;
+        }
+        if (im.invokeGetter(name) == null &&
+            defaultValue != null &&
+            !isGetterOnly) {
+          im.invokeSetter(name, defaultValue);
+        }
+        if (meta?.inject != true) {
+          return;
+        }
+      }
+      fieldValue = property.raw
+          ? this.deserializeObject(fieldValue, propertyContext)
+          : property.value;
+      if (isGetterOnly) {
+        if (inheritedPublicFieldNames.contains(name) &&
+            !mappedFields.contains(property.name)) {
+          mappedFields.add(property.name);
+        }
+      } else {
+        if (meta?.rawJson == true && typeInfo.type == String) {
+          if (fieldValue is Map || fieldValue is List) {
+            fieldValue = JsonEncoder().convert(fieldValue);
+          } else if (fieldValue == null) {
+            fieldValue = null;
+          } else {
+            fieldValue = fieldValue.toString();
+          }
+        }
+
+        fieldValue = _mapper.applyValueDecorator(fieldValue, typeInfo) ?? defaultValue;
+        im.invokeSetter(name, fieldValue);
+        mappedFields.add(property.name);
+      }
+    });
+
+    final discriminatorPropertyName =
+        _mapper.typeInfoHandler.getDiscriminatorProperty(classInfo, context.options);
+    final unmappedFields = jsonMap.map.keys
+        .where((field) =>
+            !mappedFields.contains(field) && field != discriminatorPropertyName)
+        .toList();
+    if (unmappedFields.isNotEmpty) {
+      final jsonAnySetter = classInfo.getJsonAnySetter(context.options.scheme);
+      for (var field in unmappedFields) {
+        final jsonSetter =
+            classInfo.getJsonSetter(field, context.options.scheme) ??
+                jsonAnySetter;
+        final params = jsonSetter == jsonAnySetter
+            ? [field, jsonMap.map[field]]
+            : [jsonMap.map[field]];
+        if (jsonSetter != null) {
+          im.invoke(jsonSetter.simpleName, params);
+        }
+      }
+    }
+
+    return _mapper.applyValueDecorator(objectInstance, typeInfo);
+  }
+
+  TypeInfo? _detectObjectType(dynamic objectInstance, Type? objectType,
+      JsonMap objectJsonMap, DeserializationContext context) {
+    final objectClassInfo = _mapper.classes[objectType];
+    if (objectClassInfo == null) {
+      return null;
+    }
+    final meta = objectClassInfo.getMeta(context.options.scheme);
+
+    if (objectInstance is Map<String, dynamic>) {
+      objectJsonMap = JsonMap(objectInstance, meta);
+    }
+    final typeInfo = _mapper.typeInfoHandler.getTypeInfo(objectType ?? objectInstance.runtimeType);
+
+    final discriminatorProperty =
+        _mapper.typeInfoHandler.getDiscriminatorProperty(objectClassInfo, context.options);
+    final discriminatorValue = discriminatorProperty != null &&
+            objectJsonMap.hasProperty(discriminatorProperty)
+        ? objectJsonMap.getPropertyValue(discriminatorProperty)
+        : null;
+    if (discriminatorProperty != null && discriminatorValue != null) {
+      final declarationMirror =
+          objectClassInfo.getDeclarationMirror(discriminatorProperty);
+      if (declarationMirror != null) {
+        final discriminatorType = ReflectionHandler.getDeclarationType(declarationMirror);
+        final value = this.deserializeObject(discriminatorValue,
+            context.reBuild(typeInfo: _mapper.typeInfoHandler.getTypeInfo(discriminatorType)));
+        if (value is Type) {
+          return _mapper.typeInfoHandler.getTypeInfo(value);
+        }
+
+        if (_mapper.discriminatorToType[value] == null) {
+          final validDiscriminators = ClassInfo.getAllSubTypes(
+                  _mapper.classes, objectClassInfo)
+              .map((e) => e.getMeta(context.options.scheme)!.discriminatorValue)
+              .toList();
+          throw JsonMapperSubtypeError(
+            discriminatorValue,
+            validDiscriminators,
+            objectClassInfo,
+          );
+        }
+
+        return _mapper.typeInfoHandler.getTypeInfo(_mapper.discriminatorToType[value]!);
+      }
+    }
+    if (discriminatorValue != null) {
+      final targetType = _mapper.typeInfoHandler.getTypeByStringName(discriminatorValue);
+      return _mapper.classes[targetType] != null
+          ? _mapper.typeInfoHandler.getTypeInfo(_mapper.classes[targetType]!.reflectedType!)
+          : typeInfo;
+    }
+    return typeInfo;
+  }
+
+  void _enumerateConstructorParameters(ClassInfo classInfo, JsonMap jsonMap,
+      DeserializationContext context, Function filter, Function visitor) {
+    final classMeta = classInfo.getMeta(context.options.scheme);
+    final scheme =
+        classMeta != null ? classMeta.scheme : context.options.scheme;
+    final methodMirror = classInfo.getJsonConstructor(scheme);
+    if (methodMirror == null) {
+      return;
+    }
+    for (var param in methodMirror.parameters) {
+      if (!filter(param)) {
+        return;
+      }
+      final name = param.simpleName;
+      final declarationMirror = classInfo.getDeclarationMirror(name) ?? param;
+      final paramType = param.hasReflectedType
+          ? param.reflectedType
+          : param.hasDynamicReflectedType
+              ? param.dynamicReflectedType
+              : _mapper.typeInfoHandler.getGenericParameterTypeByIndex(
+                      methodMirror.parameters.indexOf(param),
+                      context.typeInfo!) ??
+                  dynamic;
+      var paramTypeInfo = _mapper.typeInfoHandler.getTypeInfo(paramType);
+      paramTypeInfo = paramTypeInfo.isDynamic
+          ? _mapper.typeInfoHandler.getTypeInfo(ReflectionHandler.getDeclarationType(declarationMirror))
+          : paramTypeInfo;
+      final meta = classInfo.getDeclarationMeta(
+              declarationMirror, context.options.scheme) ??
+          classInfo.getDeclarationMeta(param, context.options.scheme);
+      final propertyContext = context.reBuild(
+          classMeta: classMeta,
+          jsonPropertyMeta: meta,
+          typeInfo: paramTypeInfo,
+          parentJsonMaps: <JsonMap>[
+            ...(context.parentJsonMaps ?? []),
+            jsonMap
+          ]);
+
+      dynamic finalValueForVisitor;
+      String? jsonNameForVisitor;
+
+      if (meta?.flatten == true) {
+        finalValueForVisitor = this.deserializeObject(jsonMap.map, propertyContext.reBuild(jsonPropertyMeta: null));
+        jsonNameForVisitor = context.transformIdentifier(meta?.name ?? name);
+      } else {
+        final property = _mapper.resolveProperty(
+            name,
+            jsonMap,
+            propertyContext,
+            classMeta,
+            meta,
+            (_, resolvedJsonNameFromCallback, defaultValueFromCallback) =>
+                jsonMap.hasProperty(resolvedJsonNameFromCallback)
+                    ? jsonMap.getPropertyValue(resolvedJsonNameFromCallback) ?? defaultValueFromCallback
+                    : defaultValueFromCallback);
+        jsonNameForVisitor = property.name;
+        if (property.raw) {
+            finalValueForVisitor = this.deserializeObject(property.value, propertyContext);
+        } else {
+            finalValueForVisitor = property.value;
+        }
+      }
+
+      visitor(param, name, jsonNameForVisitor, classMeta, meta, finalValueForVisitor, paramTypeInfo);
+    }
+  }
+
+  Map<Symbol, dynamic> _getNamedArguments(
+      ClassInfo cm, JsonMap jsonMap, DeserializationContext context) {
+    final result = <Symbol, dynamic>{};
+
+    _enumerateConstructorParameters(
+        cm, jsonMap, context, (param) => param.isNamed, (param, name, jsonName,
+            classMeta, JsonProperty? meta, value, TypeInfo typeInfo) {
+      if (!FieldHandler.isFieldIgnoredByValue(value, classMeta, meta, context.options)) {
+        result[Symbol(name)] = value;
+      }
+    });
+
+    return result;
+  }
+
+  List _getPositionalArguments(ClassInfo cm, JsonMap jsonMap,
+      DeserializationContext context, List<String> positionalArgumentNames) {
+    final result = [];
+
+    _enumerateConstructorParameters(
+        cm, jsonMap, context, (param) => !param.isOptional && !param.isNamed,
+        (param, name, jsonName, classMeta, JsonProperty? meta, value,
+            TypeInfo typeInfo) {
+      positionalArgumentNames.add(name);
+      result.add(FieldHandler.isFieldIgnoredByValue(value, classMeta, meta, context.options)
+          ? null
+          : value);
+    });
+
+    return result;
+  }
+}