diff --git a/json_serializable/CHANGELOG.md b/json_serializable/CHANGELOG.md index 93ca8f831..0effefc60 100644 --- a/json_serializable/CHANGELOG.md +++ b/json_serializable/CHANGELOG.md @@ -1,5 +1,6 @@ -## 6.7.0-dev +## 6.7.0 +- Support `Record` types. - Require Dart 3.0 - Require `analyzer: ^5.12.0` diff --git a/json_serializable/README.md b/json_serializable/README.md index 4f1d53fe5..5e7498540 100644 --- a/json_serializable/README.md +++ b/json_serializable/README.md @@ -152,11 +152,11 @@ Out of the box, `json_serializable` supports many common types in the [dart:core](https://api.dart.dev/stable/dart-core/dart-core-library.html) library: [`BigInt`], [`bool`], [`DateTime`], [`double`], [`Duration`], [`Enum`], [`int`], -[`Iterable`], [`List`], [`Map`], [`num`], [`Object`], [`Set`], [`String`], -[`Uri`] +[`Iterable`], [`List`], [`Map`], [`num`], [`Object`], [`Record`], [`Set`], +[`String`], [`Uri`] The collection types – -[`Iterable`], [`List`], [`Map`], [`Set`] +[`Iterable`], [`List`], [`Map`], [`Record`], [`Set`] – can contain values of all the above types. For [`Map`], the key value must be one of @@ -313,6 +313,7 @@ targets: [`Map`]: https://api.dart.dev/stable/dart-core/Map-class.html [`num`]: https://api.dart.dev/stable/dart-core/num-class.html [`Object`]: https://api.dart.dev/stable/dart-core/Object-class.html +[`Record`]: https://api.dart.dev/stable/dart-core/Record-class.html [`Set`]: https://api.dart.dev/stable/dart-core/Set-class.html [`String`]: https://api.dart.dev/stable/dart-core/String-class.html [`Uri`]: https://api.dart.dev/stable/dart-core/Uri-class.html diff --git a/json_serializable/build.yaml b/json_serializable/build.yaml index 66f56a880..fb0052e74 100644 --- a/json_serializable/build.yaml +++ b/json_serializable/build.yaml @@ -71,6 +71,7 @@ builders: - .type_map.dart - .type_num.dart - .type_object.dart + - .type_record.dart - .type_set.dart - .type_string.dart - .type_uri.dart diff --git a/json_serializable/lib/src/enum_utils.dart b/json_serializable/lib/src/enum_utils.dart index 467d47161..d5aa4d2d2 100644 --- a/json_serializable/lib/src/enum_utils.dart +++ b/json_serializable/lib/src/enum_utils.dart @@ -52,7 +52,9 @@ Map? _enumMap( DartType targetType, { bool nullWithNoAnnotation = false, }) { - final annotation = _jsonEnumChecker.firstAnnotationOf(targetType.element!); + final targetTypeElement = targetType.element; + if (targetTypeElement == null) return null; + final annotation = _jsonEnumChecker.firstAnnotationOf(targetTypeElement); final jsonEnum = _fromAnnotation(annotation); final enumFields = iterateEnumFields(targetType); diff --git a/json_serializable/lib/src/helper_core.dart b/json_serializable/lib/src/helper_core.dart index 3e6d6b88d..5a8248c66 100644 --- a/json_serializable/lib/src/helper_core.dart +++ b/json_serializable/lib/src/helper_core.dart @@ -77,8 +77,9 @@ $converterOrKeyInstructions } else if (field.type != error.type) { message = '$message because of type `${typeToCode(error.type)}`'; } else { + final element = error.type.element?.name; todo = ''' -To support the type `${error.type.element!.name}` you can: +To support the type `${element ?? error.type}` you can: $converterOrKeyInstructions'''; } diff --git a/json_serializable/lib/src/json_key_utils.dart b/json_serializable/lib/src/json_key_utils.dart index 8ba78229d..42eb0cfce 100644 --- a/json_serializable/lib/src/json_key_utils.dart +++ b/json_serializable/lib/src/json_key_utils.dart @@ -64,7 +64,7 @@ KeyConfig _from(FieldElement element, ClassConfig classAnnotation) { // literal, which is NOT supported! badType = 'Function'; } else if (!reader.isLiteral) { - badType = dartObject.type!.element!.name; + badType = dartObject.type!.element?.name; } if (badType != null) { diff --git a/json_serializable/lib/src/settings.dart b/json_serializable/lib/src/settings.dart index c73df1b7b..62d35a93c 100644 --- a/json_serializable/lib/src/settings.dart +++ b/json_serializable/lib/src/settings.dart @@ -16,6 +16,7 @@ import 'type_helpers/iterable_helper.dart'; import 'type_helpers/json_converter_helper.dart'; import 'type_helpers/json_helper.dart'; import 'type_helpers/map_helper.dart'; +import 'type_helpers/record_helper.dart'; import 'type_helpers/uri_helper.dart'; import 'type_helpers/value_helper.dart'; @@ -24,6 +25,7 @@ class Settings { IterableHelper(), MapHelper(), EnumHelper(), + RecordHelper(), ValueHelper(), ]; diff --git a/json_serializable/lib/src/type_helpers/record_helper.dart b/json_serializable/lib/src/type_helpers/record_helper.dart new file mode 100644 index 000000000..f086948bf --- /dev/null +++ b/json_serializable/lib/src/type_helpers/record_helper.dart @@ -0,0 +1,124 @@ +import 'package:analyzer/dart/element/type.dart'; +import 'package:source_helper/source_helper.dart'; + +import '../type_helper.dart'; +import '../utils.dart'; + +class RecordHelper extends TypeHelper { + const RecordHelper(); + + @override + Object? deserialize( + DartType targetType, + String expression, + TypeHelperContextWithConfig context, + bool defaultProvided, + ) { + if (targetType is! RecordType) return null; + + final items = []; + + const paramName = r'$jsonValue'; + + var index = 1; + for (var field in targetType.positionalFields) { + final indexer = escapeDartString('\$$index'); + items.add( + context.deserialize(field.type, '$paramName[$indexer]')!, + ); + index++; + } + for (var field in targetType.namedFields) { + final indexer = escapeDartString(field.name); + items.add( + '${field.name}:' + '${context.deserialize(field.type, '$paramName[$indexer]')!}', + ); + } + + if (items.isEmpty) { + return '()'; + } + + context.addMember( + _recordConvertImpl( + nullable: targetType.isNullableType, anyMap: context.config.anyMap), + ); + + final recordLiteral = '(${items.map((e) => '$e,').join()})'; + + final helperName = _recordConvertName( + nullable: targetType.isNullableType, + anyMap: context.config.anyMap, + ); + + return ''' +$helperName( + $expression, + ($paramName) => $recordLiteral, +)'''; + } + + @override + Object? serialize( + DartType targetType, + String expression, + TypeHelperContextWithConfig context, + ) { + if (targetType is! RecordType) return null; + + final maybeBang = targetType.isNullableType ? '!' : ''; + + final items = []; + + var index = 1; + for (var field in targetType.positionalFields) { + final indexer = escapeDartString('\$$index'); + items.add( + '$indexer:' + '${context.serialize(field.type, '$expression$maybeBang.\$$index')!}', + ); + index++; + } + for (var field in targetType.namedFields) { + final indexer = escapeDartString(field.name); + items.add( + '$indexer:${context.serialize( + field.type, + '$expression$maybeBang.${field.name}', + )!}', + ); + } + + final mapValue = '{${items.map((e) => '$e,').join()}}'; + + return targetType.isNullableType + ? ifNullOrElse( + expression, + 'null', + mapValue, + ) + : mapValue; + } +} + +String _recordConvertName({required bool nullable, required bool anyMap}) => + '_\$recordConvert${anyMap ? 'Any' : ''}${nullable ? 'Nullable' : ''}'; + +String _recordConvertImpl({required bool nullable, required bool anyMap}) { + final name = _recordConvertName(nullable: nullable, anyMap: anyMap); + + var expression = + 'convert(value as ${anyMap ? 'Map' : 'Map'})'; + if (nullable) { + expression = ifNullOrElse('value', 'null', expression); + } + + return ''' +\$Rec${nullable ? '?' : ''} $name<\$Rec>( + Object? value, + \$Rec Function(Map) convert, +) => + $expression; +'''; +} diff --git a/json_serializable/pubspec.yaml b/json_serializable/pubspec.yaml index ac4be2a86..d64039063 100644 --- a/json_serializable/pubspec.yaml +++ b/json_serializable/pubspec.yaml @@ -1,5 +1,5 @@ name: json_serializable -version: 6.7.0-dev +version: 6.7.0 description: >- Automatically generate code for converting to and from JSON by annotating Dart classes. diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.dart b/json_serializable/test/kitchen_sink/kitchen_sink.dart index e194dbfbc..b0ff20f00 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.dart @@ -184,6 +184,8 @@ class KitchenSink implements k.KitchenSink { _validatedPropertyNo42 = value; } + k.RecordSample? recordField; + bool operator ==(Object other) => k.sinkEquals(this, other); static Object? _trickyValueAccessor(Map json, String key) { diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.g.dart b/json_serializable/test/kitchen_sink/kitchen_sink.g.dart index c795c6c13..1396ff044 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.g.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.g.dart @@ -85,7 +85,15 @@ KitchenSink _$KitchenSinkFromJson(Map json) => KitchenSink( SimpleObject.fromJson(json['simpleObject'] as Map) ..strictKeysObject = StrictKeysObject.fromJson( json['strictKeysObject'] as Map) - ..validatedPropertyNo42 = json['validatedPropertyNo42'] as int?; + ..validatedPropertyNo42 = json['validatedPropertyNo42'] as int? + ..recordField = _$recordConvertNullable( + json['recordField'], + ($jsonValue) => ( + $jsonValue[r'$1'] as int, + $jsonValue[r'$2'] as String, + truth: $jsonValue['truth'] as bool, + ), + ); Map _$KitchenSinkToJson(KitchenSink instance) => { @@ -132,8 +140,21 @@ Map _$KitchenSinkToJson(KitchenSink instance) => 'simpleObject': instance.simpleObject, 'strictKeysObject': instance.strictKeysObject, 'validatedPropertyNo42': instance.validatedPropertyNo42, + 'recordField': instance.recordField == null + ? null + : { + r'$1': instance.recordField!.$1, + r'$2': instance.recordField!.$2, + 'truth': instance.recordField!.truth, + }, }; +$Rec? _$recordConvertNullable<$Rec>( + Object? value, + $Rec Function(Map) convert, +) => + value == null ? null : convert(value as Map); + JsonConverterTestClass _$JsonConverterTestClassFromJson( Map json) => JsonConverterTestClass( diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map.dart b/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map.dart index cd0abae63..6f8b5c69f 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map.dart @@ -184,6 +184,8 @@ class KitchenSink implements k.KitchenSink { _validatedPropertyNo42 = value; } + k.RecordSample? recordField; + bool operator ==(Object other) => k.sinkEquals(this, other); static Object? _trickyValueAccessor(Map json, String key) { diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map.g.dart b/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map.g.dart index ce7520a1e..6cfb749ea 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map.g.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map.g.dart @@ -77,7 +77,15 @@ KitchenSink _$KitchenSinkFromJson(Map json) => KitchenSink( ..simpleObject = SimpleObject.fromJson(json['simpleObject'] as Map) ..strictKeysObject = StrictKeysObject.fromJson(json['strictKeysObject'] as Map) - ..validatedPropertyNo42 = json['validatedPropertyNo42'] as int?; + ..validatedPropertyNo42 = json['validatedPropertyNo42'] as int? + ..recordField = _$recordConvertAnyNullable( + json['recordField'], + ($jsonValue) => ( + $jsonValue[r'$1'] as int, + $jsonValue[r'$2'] as String, + truth: $jsonValue['truth'] as bool, + ), + ); Map _$KitchenSinkToJson(KitchenSink instance) => { @@ -124,8 +132,21 @@ Map _$KitchenSinkToJson(KitchenSink instance) => 'simpleObject': instance.simpleObject, 'strictKeysObject': instance.strictKeysObject, 'validatedPropertyNo42': instance.validatedPropertyNo42, + 'recordField': instance.recordField == null + ? null + : { + r'$1': instance.recordField!.$1, + r'$2': instance.recordField!.$2, + 'truth': instance.recordField!.truth, + }, }; +$Rec? _$recordConvertAnyNullable<$Rec>( + Object? value, + $Rec Function(Map) convert, +) => + value == null ? null : convert(value as Map); + JsonConverterTestClass _$JsonConverterTestClassFromJson(Map json) => JsonConverterTestClass( const DurationMillisecondConverter().fromJson(json['duration'] as int?), diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map__checked.dart b/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map__checked.dart index b01ef3341..fe5bcbba7 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map__checked.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map__checked.dart @@ -185,6 +185,8 @@ class KitchenSink implements k.KitchenSink { _validatedPropertyNo42 = value; } + k.RecordSample? recordField; + bool operator ==(Object other) => k.sinkEquals(this, other); static Object? _trickyValueAccessor(Map json, String key) { diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map__checked.g.dart b/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map__checked.g.dart index a9e48d1a6..02fc36586 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map__checked.g.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.g_any_map__checked.g.dart @@ -121,6 +121,16 @@ KitchenSink _$KitchenSinkFromJson(Map json) => $checkedCreate( (v) => val.strictKeysObject = StrictKeysObject.fromJson(v as Map)); $checkedConvert('validatedPropertyNo42', (v) => val.validatedPropertyNo42 = v as int?); + $checkedConvert( + 'recordField', + (v) => val.recordField = _$recordConvertAnyNullable( + v, + ($jsonValue) => ( + $jsonValue[r'$1'] as int, + $jsonValue[r'$2'] as String, + truth: $jsonValue['truth'] as bool, + ), + )); return val; }, fieldKeyMap: const { @@ -175,8 +185,21 @@ Map _$KitchenSinkToJson(KitchenSink instance) => 'simpleObject': instance.simpleObject, 'strictKeysObject': instance.strictKeysObject, 'validatedPropertyNo42': instance.validatedPropertyNo42, + 'recordField': instance.recordField == null + ? null + : { + r'$1': instance.recordField!.$1, + r'$2': instance.recordField!.$2, + 'truth': instance.recordField!.truth, + }, }; +$Rec? _$recordConvertAnyNullable<$Rec>( + Object? value, + $Rec Function(Map) convert, +) => + value == null ? null : convert(value as Map); + JsonConverterTestClass _$JsonConverterTestClassFromJson(Map json) => $checkedCreate( 'JsonConverterTestClass', diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.g_exclude_null.dart b/json_serializable/test/kitchen_sink/kitchen_sink.g_exclude_null.dart index 46b2ea3b7..9476908a6 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.g_exclude_null.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.g_exclude_null.dart @@ -186,6 +186,8 @@ class KitchenSink implements k.KitchenSink { _validatedPropertyNo42 = value; } + k.RecordSample? recordField; + bool operator ==(Object other) => k.sinkEquals(this, other); static Object? _trickyValueAccessor(Map json, String key) { diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.g_exclude_null.g.dart b/json_serializable/test/kitchen_sink/kitchen_sink.g_exclude_null.g.dart index d69950e1b..e9f8662ad 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.g_exclude_null.g.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.g_exclude_null.g.dart @@ -85,7 +85,15 @@ KitchenSink _$KitchenSinkFromJson(Map json) => KitchenSink( SimpleObject.fromJson(json['simpleObject'] as Map) ..strictKeysObject = StrictKeysObject.fromJson( json['strictKeysObject'] as Map) - ..validatedPropertyNo42 = json['validatedPropertyNo42'] as int?; + ..validatedPropertyNo42 = json['validatedPropertyNo42'] as int? + ..recordField = _$recordConvertNullable( + json['recordField'], + ($jsonValue) => ( + $jsonValue[r'$1'] as int, + $jsonValue[r'$2'] as String, + truth: $jsonValue['truth'] as bool, + ), + ); Map _$KitchenSinkToJson(KitchenSink instance) { final val = {}; @@ -139,9 +147,24 @@ Map _$KitchenSinkToJson(KitchenSink instance) { val['simpleObject'] = instance.simpleObject; val['strictKeysObject'] = instance.strictKeysObject; writeNotNull('validatedPropertyNo42', instance.validatedPropertyNo42); + writeNotNull( + 'recordField', + instance.recordField == null + ? null + : { + r'$1': instance.recordField!.$1, + r'$2': instance.recordField!.$2, + 'truth': instance.recordField!.truth, + }); return val; } +$Rec? _$recordConvertNullable<$Rec>( + Object? value, + $Rec Function(Map) convert, +) => + value == null ? null : convert(value as Map); + JsonConverterTestClass _$JsonConverterTestClassFromJson( Map json) => JsonConverterTestClass( diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.g_explicit_to_json.dart b/json_serializable/test/kitchen_sink/kitchen_sink.g_explicit_to_json.dart index 02bd2a683..48afb79fc 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.g_explicit_to_json.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.g_explicit_to_json.dart @@ -186,6 +186,8 @@ class KitchenSink implements k.KitchenSink { _validatedPropertyNo42 = value; } + k.RecordSample? recordField; + bool operator ==(Object other) => k.sinkEquals(this, other); static Object? _trickyValueAccessor(Map json, String key) { diff --git a/json_serializable/test/kitchen_sink/kitchen_sink.g_explicit_to_json.g.dart b/json_serializable/test/kitchen_sink/kitchen_sink.g_explicit_to_json.g.dart index a38b42bf0..24101a1b6 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink.g_explicit_to_json.g.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink.g_explicit_to_json.g.dart @@ -85,7 +85,15 @@ KitchenSink _$KitchenSinkFromJson(Map json) => KitchenSink( SimpleObject.fromJson(json['simpleObject'] as Map) ..strictKeysObject = StrictKeysObject.fromJson( json['strictKeysObject'] as Map) - ..validatedPropertyNo42 = json['validatedPropertyNo42'] as int?; + ..validatedPropertyNo42 = json['validatedPropertyNo42'] as int? + ..recordField = _$recordConvertNullable( + json['recordField'], + ($jsonValue) => ( + $jsonValue[r'$1'] as int, + $jsonValue[r'$2'] as String, + truth: $jsonValue['truth'] as bool, + ), + ); Map _$KitchenSinkToJson(KitchenSink instance) => { @@ -134,8 +142,21 @@ Map _$KitchenSinkToJson(KitchenSink instance) => 'simpleObject': instance.simpleObject.toJson(), 'strictKeysObject': instance.strictKeysObject.toJson(), 'validatedPropertyNo42': instance.validatedPropertyNo42, + 'recordField': instance.recordField == null + ? null + : { + r'$1': instance.recordField!.$1, + r'$2': instance.recordField!.$2, + 'truth': instance.recordField!.truth, + }, }; +$Rec? _$recordConvertNullable<$Rec>( + Object? value, + $Rec Function(Map) convert, +) => + value == null ? null : convert(value as Map); + JsonConverterTestClass _$JsonConverterTestClassFromJson( Map json) => JsonConverterTestClass( diff --git a/json_serializable/test/kitchen_sink/kitchen_sink_interface.dart b/json_serializable/test/kitchen_sink/kitchen_sink_interface.dart index 9f8740943..57673b70f 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink_interface.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink_interface.dart @@ -120,9 +120,17 @@ abstract class KitchenSink { int? validatedPropertyNo42; + RecordSample? recordField; + Map toJson(); } +typedef RecordSample = ( + int, + String, { + bool truth, +}); + // TODO: finish this... bool sinkEquals(KitchenSink a, Object other) => other is KitchenSink && @@ -145,4 +153,5 @@ bool sinkEquals(KitchenSink a, Object other) => deepEquals(a.crazyComplex, other.crazyComplex) && // val a.writeNotNull == other.writeNotNull && - a.string == other.string; + a.string == other.string && + a.recordField == other.recordField; diff --git a/json_serializable/test/kitchen_sink/kitchen_sink_test.dart b/json_serializable/test/kitchen_sink/kitchen_sink_test.dart index 67e68400a..f3519050b 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink_test.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink_test.dart @@ -294,7 +294,11 @@ const _nonNullableFields = { 'strictKeysObject' }; -const _encodedAsMapKeys = {'simpleObject', 'strictKeysObject'}; +const _encodedAsMapKeys = { + 'simpleObject', + 'strictKeysObject', + 'recordField', +}; const _iterableMapKeys = { 'bigIntMap', diff --git a/json_serializable/test/kitchen_sink/kitchen_sink_test_shared.dart b/json_serializable/test/kitchen_sink/kitchen_sink_test_shared.dart index 7bf34f035..fc235bc05 100644 --- a/json_serializable/test/kitchen_sink/kitchen_sink_test_shared.dart +++ b/json_serializable/test/kitchen_sink/kitchen_sink_test_shared.dart @@ -40,7 +40,12 @@ const validValues = { trickyKeyName: 'string', 'simpleObject': {'value': 42}, 'strictKeysObject': {'value': 10, 'custom_field': 'cool'}, - 'validatedPropertyNo42': 0 + 'validatedPropertyNo42': 0, + 'recordField': { + '\$1': 0, + '\$2': 'string', + 'truth': true, + }, }; const invalidValueTypes = { @@ -77,7 +82,8 @@ const invalidValueTypes = { 'value': 10, 'invalid_key': true, }, - 'validatedPropertyNo42': true + 'validatedPropertyNo42': true, + 'recordField': true, }; const disallowNullKeys = { diff --git a/json_serializable/test/supported_types/input.type_record.dart b/json_serializable/test/supported_types/input.type_record.dart new file mode 100644 index 000000000..0f226fed3 --- /dev/null +++ b/json_serializable/test/supported_types/input.type_record.dart @@ -0,0 +1,861 @@ +// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file +// for details. All rights reserved. Use of this source code is governed by a +// BSD-style license that can be found in the LICENSE file. + +import 'package:json_annotation/json_annotation.dart'; +import 'enum_type.dart'; + +part 'input.type_record.g.dart'; + +typedef RecordTypeDef = (); + +@JsonSerializable() +class SimpleClass { + final RecordTypeDef value; + + SimpleClass( + this.value, + ); + + factory SimpleClass.fromJson(Map json) => + _$SimpleClassFromJson(json); + + Map toJson() => _$SimpleClassToJson(this); +} + +@JsonSerializable() +class SimpleClassNullable { + final RecordTypeDef? value; + + SimpleClassNullable( + this.value, + ); + + factory SimpleClassNullable.fromJson(Map json) => + _$SimpleClassNullableFromJson(json); + + Map toJson() => _$SimpleClassNullableToJson(this); +} + +typedef SimpleClassOfBigIntTypeDef = (BigInt, {BigInt named}); + +@JsonSerializable() +class SimpleClassOfBigInt { + final SimpleClassOfBigIntTypeDef value; + + SimpleClassOfBigInt( + this.value, + ); + + factory SimpleClassOfBigInt.fromJson(Map json) => + _$SimpleClassOfBigIntFromJson(json); + + Map toJson() => _$SimpleClassOfBigIntToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfBigInt { + final SimpleClassOfBigIntTypeDef? value; + + SimpleClassNullableOfBigInt( + this.value, + ); + + factory SimpleClassNullableOfBigInt.fromJson(Map json) => + _$SimpleClassNullableOfBigIntFromJson(json); + + Map toJson() => _$SimpleClassNullableOfBigIntToJson(this); +} + +typedef SimpleClassOfBigIntNullableTypeDef = (BigInt?, {BigInt? named}); + +@JsonSerializable() +class SimpleClassOfBigIntNullable { + final SimpleClassOfBigIntNullableTypeDef value; + + SimpleClassOfBigIntNullable( + this.value, + ); + + factory SimpleClassOfBigIntNullable.fromJson(Map json) => + _$SimpleClassOfBigIntNullableFromJson(json); + + Map toJson() => _$SimpleClassOfBigIntNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfBigIntNullable { + final SimpleClassOfBigIntNullableTypeDef? value; + + SimpleClassNullableOfBigIntNullable( + this.value, + ); + + factory SimpleClassNullableOfBigIntNullable.fromJson( + Map json) => + _$SimpleClassNullableOfBigIntNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfBigIntNullableToJson(this); +} + +typedef SimpleClassOfBoolTypeDef = (bool, {bool named}); + +@JsonSerializable() +class SimpleClassOfBool { + final SimpleClassOfBoolTypeDef value; + + SimpleClassOfBool( + this.value, + ); + + factory SimpleClassOfBool.fromJson(Map json) => + _$SimpleClassOfBoolFromJson(json); + + Map toJson() => _$SimpleClassOfBoolToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfBool { + final SimpleClassOfBoolTypeDef? value; + + SimpleClassNullableOfBool( + this.value, + ); + + factory SimpleClassNullableOfBool.fromJson(Map json) => + _$SimpleClassNullableOfBoolFromJson(json); + + Map toJson() => _$SimpleClassNullableOfBoolToJson(this); +} + +typedef SimpleClassOfBoolNullableTypeDef = (bool?, {bool? named}); + +@JsonSerializable() +class SimpleClassOfBoolNullable { + final SimpleClassOfBoolNullableTypeDef value; + + SimpleClassOfBoolNullable( + this.value, + ); + + factory SimpleClassOfBoolNullable.fromJson(Map json) => + _$SimpleClassOfBoolNullableFromJson(json); + + Map toJson() => _$SimpleClassOfBoolNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfBoolNullable { + final SimpleClassOfBoolNullableTypeDef? value; + + SimpleClassNullableOfBoolNullable( + this.value, + ); + + factory SimpleClassNullableOfBoolNullable.fromJson( + Map json) => + _$SimpleClassNullableOfBoolNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfBoolNullableToJson(this); +} + +typedef SimpleClassOfDateTimeTypeDef = (DateTime, {DateTime named}); + +@JsonSerializable() +class SimpleClassOfDateTime { + final SimpleClassOfDateTimeTypeDef value; + + SimpleClassOfDateTime( + this.value, + ); + + factory SimpleClassOfDateTime.fromJson(Map json) => + _$SimpleClassOfDateTimeFromJson(json); + + Map toJson() => _$SimpleClassOfDateTimeToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfDateTime { + final SimpleClassOfDateTimeTypeDef? value; + + SimpleClassNullableOfDateTime( + this.value, + ); + + factory SimpleClassNullableOfDateTime.fromJson(Map json) => + _$SimpleClassNullableOfDateTimeFromJson(json); + + Map toJson() => _$SimpleClassNullableOfDateTimeToJson(this); +} + +typedef SimpleClassOfDateTimeNullableTypeDef = (DateTime?, {DateTime? named}); + +@JsonSerializable() +class SimpleClassOfDateTimeNullable { + final SimpleClassOfDateTimeNullableTypeDef value; + + SimpleClassOfDateTimeNullable( + this.value, + ); + + factory SimpleClassOfDateTimeNullable.fromJson(Map json) => + _$SimpleClassOfDateTimeNullableFromJson(json); + + Map toJson() => _$SimpleClassOfDateTimeNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfDateTimeNullable { + final SimpleClassOfDateTimeNullableTypeDef? value; + + SimpleClassNullableOfDateTimeNullable( + this.value, + ); + + factory SimpleClassNullableOfDateTimeNullable.fromJson( + Map json) => + _$SimpleClassNullableOfDateTimeNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfDateTimeNullableToJson(this); +} + +typedef SimpleClassOfDoubleTypeDef = (double, {double named}); + +@JsonSerializable() +class SimpleClassOfDouble { + final SimpleClassOfDoubleTypeDef value; + + SimpleClassOfDouble( + this.value, + ); + + factory SimpleClassOfDouble.fromJson(Map json) => + _$SimpleClassOfDoubleFromJson(json); + + Map toJson() => _$SimpleClassOfDoubleToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfDouble { + final SimpleClassOfDoubleTypeDef? value; + + SimpleClassNullableOfDouble( + this.value, + ); + + factory SimpleClassNullableOfDouble.fromJson(Map json) => + _$SimpleClassNullableOfDoubleFromJson(json); + + Map toJson() => _$SimpleClassNullableOfDoubleToJson(this); +} + +typedef SimpleClassOfDoubleNullableTypeDef = (double?, {double? named}); + +@JsonSerializable() +class SimpleClassOfDoubleNullable { + final SimpleClassOfDoubleNullableTypeDef value; + + SimpleClassOfDoubleNullable( + this.value, + ); + + factory SimpleClassOfDoubleNullable.fromJson(Map json) => + _$SimpleClassOfDoubleNullableFromJson(json); + + Map toJson() => _$SimpleClassOfDoubleNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfDoubleNullable { + final SimpleClassOfDoubleNullableTypeDef? value; + + SimpleClassNullableOfDoubleNullable( + this.value, + ); + + factory SimpleClassNullableOfDoubleNullable.fromJson( + Map json) => + _$SimpleClassNullableOfDoubleNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfDoubleNullableToJson(this); +} + +typedef SimpleClassOfDurationTypeDef = (Duration, {Duration named}); + +@JsonSerializable() +class SimpleClassOfDuration { + final SimpleClassOfDurationTypeDef value; + + SimpleClassOfDuration( + this.value, + ); + + factory SimpleClassOfDuration.fromJson(Map json) => + _$SimpleClassOfDurationFromJson(json); + + Map toJson() => _$SimpleClassOfDurationToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfDuration { + final SimpleClassOfDurationTypeDef? value; + + SimpleClassNullableOfDuration( + this.value, + ); + + factory SimpleClassNullableOfDuration.fromJson(Map json) => + _$SimpleClassNullableOfDurationFromJson(json); + + Map toJson() => _$SimpleClassNullableOfDurationToJson(this); +} + +typedef SimpleClassOfDurationNullableTypeDef = (Duration?, {Duration? named}); + +@JsonSerializable() +class SimpleClassOfDurationNullable { + final SimpleClassOfDurationNullableTypeDef value; + + SimpleClassOfDurationNullable( + this.value, + ); + + factory SimpleClassOfDurationNullable.fromJson(Map json) => + _$SimpleClassOfDurationNullableFromJson(json); + + Map toJson() => _$SimpleClassOfDurationNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfDurationNullable { + final SimpleClassOfDurationNullableTypeDef? value; + + SimpleClassNullableOfDurationNullable( + this.value, + ); + + factory SimpleClassNullableOfDurationNullable.fromJson( + Map json) => + _$SimpleClassNullableOfDurationNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfDurationNullableToJson(this); +} + +typedef SimpleClassOfDynamicTypeDef = (dynamic, {dynamic named}); + +@JsonSerializable() +class SimpleClassOfDynamic { + final SimpleClassOfDynamicTypeDef value; + + SimpleClassOfDynamic( + this.value, + ); + + factory SimpleClassOfDynamic.fromJson(Map json) => + _$SimpleClassOfDynamicFromJson(json); + + Map toJson() => _$SimpleClassOfDynamicToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfDynamic { + final SimpleClassOfDynamicTypeDef? value; + + SimpleClassNullableOfDynamic( + this.value, + ); + + factory SimpleClassNullableOfDynamic.fromJson(Map json) => + _$SimpleClassNullableOfDynamicFromJson(json); + + Map toJson() => _$SimpleClassNullableOfDynamicToJson(this); +} + +typedef SimpleClassOfEnumTypeTypeDef = (EnumType, {EnumType named}); + +@JsonSerializable() +class SimpleClassOfEnumType { + final SimpleClassOfEnumTypeTypeDef value; + + SimpleClassOfEnumType( + this.value, + ); + + factory SimpleClassOfEnumType.fromJson(Map json) => + _$SimpleClassOfEnumTypeFromJson(json); + + Map toJson() => _$SimpleClassOfEnumTypeToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfEnumType { + final SimpleClassOfEnumTypeTypeDef? value; + + SimpleClassNullableOfEnumType( + this.value, + ); + + factory SimpleClassNullableOfEnumType.fromJson(Map json) => + _$SimpleClassNullableOfEnumTypeFromJson(json); + + Map toJson() => _$SimpleClassNullableOfEnumTypeToJson(this); +} + +typedef SimpleClassOfEnumTypeNullableTypeDef = (EnumType?, {EnumType? named}); + +@JsonSerializable() +class SimpleClassOfEnumTypeNullable { + final SimpleClassOfEnumTypeNullableTypeDef value; + + SimpleClassOfEnumTypeNullable( + this.value, + ); + + factory SimpleClassOfEnumTypeNullable.fromJson(Map json) => + _$SimpleClassOfEnumTypeNullableFromJson(json); + + Map toJson() => _$SimpleClassOfEnumTypeNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfEnumTypeNullable { + final SimpleClassOfEnumTypeNullableTypeDef? value; + + SimpleClassNullableOfEnumTypeNullable( + this.value, + ); + + factory SimpleClassNullableOfEnumTypeNullable.fromJson( + Map json) => + _$SimpleClassNullableOfEnumTypeNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfEnumTypeNullableToJson(this); +} + +typedef SimpleClassOfFromJsonDynamicParamTypeDef = ( + FromJsonDynamicParam, { + FromJsonDynamicParam named +}); + +@JsonSerializable() +class SimpleClassOfFromJsonDynamicParam { + final SimpleClassOfFromJsonDynamicParamTypeDef value; + + SimpleClassOfFromJsonDynamicParam( + this.value, + ); + + factory SimpleClassOfFromJsonDynamicParam.fromJson( + Map json) => + _$SimpleClassOfFromJsonDynamicParamFromJson(json); + + Map toJson() => + _$SimpleClassOfFromJsonDynamicParamToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfFromJsonDynamicParam { + final SimpleClassOfFromJsonDynamicParamTypeDef? value; + + SimpleClassNullableOfFromJsonDynamicParam( + this.value, + ); + + factory SimpleClassNullableOfFromJsonDynamicParam.fromJson( + Map json) => + _$SimpleClassNullableOfFromJsonDynamicParamFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfFromJsonDynamicParamToJson(this); +} + +typedef SimpleClassOfFromJsonNullableObjectParamTypeDef = ( + FromJsonNullableObjectParam, { + FromJsonNullableObjectParam named +}); + +@JsonSerializable() +class SimpleClassOfFromJsonNullableObjectParam { + final SimpleClassOfFromJsonNullableObjectParamTypeDef value; + + SimpleClassOfFromJsonNullableObjectParam( + this.value, + ); + + factory SimpleClassOfFromJsonNullableObjectParam.fromJson( + Map json) => + _$SimpleClassOfFromJsonNullableObjectParamFromJson(json); + + Map toJson() => + _$SimpleClassOfFromJsonNullableObjectParamToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfFromJsonNullableObjectParam { + final SimpleClassOfFromJsonNullableObjectParamTypeDef? value; + + SimpleClassNullableOfFromJsonNullableObjectParam( + this.value, + ); + + factory SimpleClassNullableOfFromJsonNullableObjectParam.fromJson( + Map json) => + _$SimpleClassNullableOfFromJsonNullableObjectParamFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfFromJsonNullableObjectParamToJson(this); +} + +typedef SimpleClassOfFromJsonObjectParamTypeDef = ( + FromJsonObjectParam, { + FromJsonObjectParam named +}); + +@JsonSerializable() +class SimpleClassOfFromJsonObjectParam { + final SimpleClassOfFromJsonObjectParamTypeDef value; + + SimpleClassOfFromJsonObjectParam( + this.value, + ); + + factory SimpleClassOfFromJsonObjectParam.fromJson( + Map json) => + _$SimpleClassOfFromJsonObjectParamFromJson(json); + + Map toJson() => + _$SimpleClassOfFromJsonObjectParamToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfFromJsonObjectParam { + final SimpleClassOfFromJsonObjectParamTypeDef? value; + + SimpleClassNullableOfFromJsonObjectParam( + this.value, + ); + + factory SimpleClassNullableOfFromJsonObjectParam.fromJson( + Map json) => + _$SimpleClassNullableOfFromJsonObjectParamFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfFromJsonObjectParamToJson(this); +} + +typedef SimpleClassOfIntTypeDef = (int, {int named}); + +@JsonSerializable() +class SimpleClassOfInt { + final SimpleClassOfIntTypeDef value; + + SimpleClassOfInt( + this.value, + ); + + factory SimpleClassOfInt.fromJson(Map json) => + _$SimpleClassOfIntFromJson(json); + + Map toJson() => _$SimpleClassOfIntToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfInt { + final SimpleClassOfIntTypeDef? value; + + SimpleClassNullableOfInt( + this.value, + ); + + factory SimpleClassNullableOfInt.fromJson(Map json) => + _$SimpleClassNullableOfIntFromJson(json); + + Map toJson() => _$SimpleClassNullableOfIntToJson(this); +} + +typedef SimpleClassOfIntNullableTypeDef = (int?, {int? named}); + +@JsonSerializable() +class SimpleClassOfIntNullable { + final SimpleClassOfIntNullableTypeDef value; + + SimpleClassOfIntNullable( + this.value, + ); + + factory SimpleClassOfIntNullable.fromJson(Map json) => + _$SimpleClassOfIntNullableFromJson(json); + + Map toJson() => _$SimpleClassOfIntNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfIntNullable { + final SimpleClassOfIntNullableTypeDef? value; + + SimpleClassNullableOfIntNullable( + this.value, + ); + + factory SimpleClassNullableOfIntNullable.fromJson( + Map json) => + _$SimpleClassNullableOfIntNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfIntNullableToJson(this); +} + +typedef SimpleClassOfNumTypeDef = (num, {num named}); + +@JsonSerializable() +class SimpleClassOfNum { + final SimpleClassOfNumTypeDef value; + + SimpleClassOfNum( + this.value, + ); + + factory SimpleClassOfNum.fromJson(Map json) => + _$SimpleClassOfNumFromJson(json); + + Map toJson() => _$SimpleClassOfNumToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfNum { + final SimpleClassOfNumTypeDef? value; + + SimpleClassNullableOfNum( + this.value, + ); + + factory SimpleClassNullableOfNum.fromJson(Map json) => + _$SimpleClassNullableOfNumFromJson(json); + + Map toJson() => _$SimpleClassNullableOfNumToJson(this); +} + +typedef SimpleClassOfNumNullableTypeDef = (num?, {num? named}); + +@JsonSerializable() +class SimpleClassOfNumNullable { + final SimpleClassOfNumNullableTypeDef value; + + SimpleClassOfNumNullable( + this.value, + ); + + factory SimpleClassOfNumNullable.fromJson(Map json) => + _$SimpleClassOfNumNullableFromJson(json); + + Map toJson() => _$SimpleClassOfNumNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfNumNullable { + final SimpleClassOfNumNullableTypeDef? value; + + SimpleClassNullableOfNumNullable( + this.value, + ); + + factory SimpleClassNullableOfNumNullable.fromJson( + Map json) => + _$SimpleClassNullableOfNumNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfNumNullableToJson(this); +} + +typedef SimpleClassOfObjectTypeDef = (Object, {Object named}); + +@JsonSerializable() +class SimpleClassOfObject { + final SimpleClassOfObjectTypeDef value; + + SimpleClassOfObject( + this.value, + ); + + factory SimpleClassOfObject.fromJson(Map json) => + _$SimpleClassOfObjectFromJson(json); + + Map toJson() => _$SimpleClassOfObjectToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfObject { + final SimpleClassOfObjectTypeDef? value; + + SimpleClassNullableOfObject( + this.value, + ); + + factory SimpleClassNullableOfObject.fromJson(Map json) => + _$SimpleClassNullableOfObjectFromJson(json); + + Map toJson() => _$SimpleClassNullableOfObjectToJson(this); +} + +typedef SimpleClassOfObjectNullableTypeDef = (Object?, {Object? named}); + +@JsonSerializable() +class SimpleClassOfObjectNullable { + final SimpleClassOfObjectNullableTypeDef value; + + SimpleClassOfObjectNullable( + this.value, + ); + + factory SimpleClassOfObjectNullable.fromJson(Map json) => + _$SimpleClassOfObjectNullableFromJson(json); + + Map toJson() => _$SimpleClassOfObjectNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfObjectNullable { + final SimpleClassOfObjectNullableTypeDef? value; + + SimpleClassNullableOfObjectNullable( + this.value, + ); + + factory SimpleClassNullableOfObjectNullable.fromJson( + Map json) => + _$SimpleClassNullableOfObjectNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfObjectNullableToJson(this); +} + +typedef SimpleClassOfStringTypeDef = (String, {String named}); + +@JsonSerializable() +class SimpleClassOfString { + final SimpleClassOfStringTypeDef value; + + SimpleClassOfString( + this.value, + ); + + factory SimpleClassOfString.fromJson(Map json) => + _$SimpleClassOfStringFromJson(json); + + Map toJson() => _$SimpleClassOfStringToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfString { + final SimpleClassOfStringTypeDef? value; + + SimpleClassNullableOfString( + this.value, + ); + + factory SimpleClassNullableOfString.fromJson(Map json) => + _$SimpleClassNullableOfStringFromJson(json); + + Map toJson() => _$SimpleClassNullableOfStringToJson(this); +} + +typedef SimpleClassOfStringNullableTypeDef = (String?, {String? named}); + +@JsonSerializable() +class SimpleClassOfStringNullable { + final SimpleClassOfStringNullableTypeDef value; + + SimpleClassOfStringNullable( + this.value, + ); + + factory SimpleClassOfStringNullable.fromJson(Map json) => + _$SimpleClassOfStringNullableFromJson(json); + + Map toJson() => _$SimpleClassOfStringNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfStringNullable { + final SimpleClassOfStringNullableTypeDef? value; + + SimpleClassNullableOfStringNullable( + this.value, + ); + + factory SimpleClassNullableOfStringNullable.fromJson( + Map json) => + _$SimpleClassNullableOfStringNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfStringNullableToJson(this); +} + +typedef SimpleClassOfUriTypeDef = (Uri, {Uri named}); + +@JsonSerializable() +class SimpleClassOfUri { + final SimpleClassOfUriTypeDef value; + + SimpleClassOfUri( + this.value, + ); + + factory SimpleClassOfUri.fromJson(Map json) => + _$SimpleClassOfUriFromJson(json); + + Map toJson() => _$SimpleClassOfUriToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfUri { + final SimpleClassOfUriTypeDef? value; + + SimpleClassNullableOfUri( + this.value, + ); + + factory SimpleClassNullableOfUri.fromJson(Map json) => + _$SimpleClassNullableOfUriFromJson(json); + + Map toJson() => _$SimpleClassNullableOfUriToJson(this); +} + +typedef SimpleClassOfUriNullableTypeDef = (Uri?, {Uri? named}); + +@JsonSerializable() +class SimpleClassOfUriNullable { + final SimpleClassOfUriNullableTypeDef value; + + SimpleClassOfUriNullable( + this.value, + ); + + factory SimpleClassOfUriNullable.fromJson(Map json) => + _$SimpleClassOfUriNullableFromJson(json); + + Map toJson() => _$SimpleClassOfUriNullableToJson(this); +} + +@JsonSerializable() +class SimpleClassNullableOfUriNullable { + final SimpleClassOfUriNullableTypeDef? value; + + SimpleClassNullableOfUriNullable( + this.value, + ); + + factory SimpleClassNullableOfUriNullable.fromJson( + Map json) => + _$SimpleClassNullableOfUriNullableFromJson(json); + + Map toJson() => + _$SimpleClassNullableOfUriNullableToJson(this); +} diff --git a/json_serializable/test/supported_types/input.type_record.g.dart b/json_serializable/test/supported_types/input.type_record.g.dart new file mode 100644 index 000000000..445701050 --- /dev/null +++ b/json_serializable/test/supported_types/input.type_record.g.dart @@ -0,0 +1,1221 @@ +// GENERATED CODE - DO NOT MODIFY BY HAND + +// ignore_for_file: lines_longer_than_80_chars, text_direction_code_point_in_literal + +part of 'input.type_record.dart'; + +// ************************************************************************** +// JsonSerializableGenerator +// ************************************************************************** + +SimpleClass _$SimpleClassFromJson(Map json) => SimpleClass( + (), + ); + +Map _$SimpleClassToJson(SimpleClass instance) => + { + 'value': {}, + }; + +SimpleClassNullable _$SimpleClassNullableFromJson(Map json) => + SimpleClassNullable( + (), + ); + +Map _$SimpleClassNullableToJson( + SimpleClassNullable instance) => + { + 'value': instance.value == null ? null : {}, + }; + +SimpleClassOfBigInt _$SimpleClassOfBigIntFromJson(Map json) => + SimpleClassOfBigInt( + _$recordConvert( + json['value'], + ($jsonValue) => ( + BigInt.parse($jsonValue[r'$1'] as String), + named: BigInt.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassOfBigIntToJson( + SimpleClassOfBigInt instance) => + { + 'value': { + r'$1': instance.value.$1.toString(), + 'named': instance.value.named.toString(), + }, + }; + +$Rec _$recordConvert<$Rec>( + Object? value, + $Rec Function(Map) convert, +) => + convert(value as Map); + +SimpleClassNullableOfBigInt _$SimpleClassNullableOfBigIntFromJson( + Map json) => + SimpleClassNullableOfBigInt( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + BigInt.parse($jsonValue[r'$1'] as String), + named: BigInt.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassNullableOfBigIntToJson( + SimpleClassNullableOfBigInt instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1.toString(), + 'named': instance.value!.named.toString(), + }, + }; + +$Rec? _$recordConvertNullable<$Rec>( + Object? value, + $Rec Function(Map) convert, +) => + value == null ? null : convert(value as Map); + +SimpleClassOfBigIntNullable _$SimpleClassOfBigIntNullableFromJson( + Map json) => + SimpleClassOfBigIntNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] == null + ? null + : BigInt.parse($jsonValue[r'$1'] as String), + named: $jsonValue['named'] == null + ? null + : BigInt.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassOfBigIntNullableToJson( + SimpleClassOfBigIntNullable instance) => + { + 'value': { + r'$1': instance.value.$1?.toString(), + 'named': instance.value.named?.toString(), + }, + }; + +SimpleClassNullableOfBigIntNullable + _$SimpleClassNullableOfBigIntNullableFromJson(Map json) => + SimpleClassNullableOfBigIntNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] == null + ? null + : BigInt.parse($jsonValue[r'$1'] as String), + named: $jsonValue['named'] == null + ? null + : BigInt.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassNullableOfBigIntNullableToJson( + SimpleClassNullableOfBigIntNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1?.toString(), + 'named': instance.value!.named?.toString(), + }, + }; + +SimpleClassOfBool _$SimpleClassOfBoolFromJson(Map json) => + SimpleClassOfBool( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as bool, + named: $jsonValue['named'] as bool, + ), + ), + ); + +Map _$SimpleClassOfBoolToJson(SimpleClassOfBool instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfBool _$SimpleClassNullableOfBoolFromJson( + Map json) => + SimpleClassNullableOfBool( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as bool, + named: $jsonValue['named'] as bool, + ), + ), + ); + +Map _$SimpleClassNullableOfBoolToJson( + SimpleClassNullableOfBool instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfBoolNullable _$SimpleClassOfBoolNullableFromJson( + Map json) => + SimpleClassOfBoolNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as bool?, + named: $jsonValue['named'] as bool?, + ), + ), + ); + +Map _$SimpleClassOfBoolNullableToJson( + SimpleClassOfBoolNullable instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfBoolNullable _$SimpleClassNullableOfBoolNullableFromJson( + Map json) => + SimpleClassNullableOfBoolNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as bool?, + named: $jsonValue['named'] as bool?, + ), + ), + ); + +Map _$SimpleClassNullableOfBoolNullableToJson( + SimpleClassNullableOfBoolNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfDateTime _$SimpleClassOfDateTimeFromJson( + Map json) => + SimpleClassOfDateTime( + _$recordConvert( + json['value'], + ($jsonValue) => ( + DateTime.parse($jsonValue[r'$1'] as String), + named: DateTime.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassOfDateTimeToJson( + SimpleClassOfDateTime instance) => + { + 'value': { + r'$1': instance.value.$1.toIso8601String(), + 'named': instance.value.named.toIso8601String(), + }, + }; + +SimpleClassNullableOfDateTime _$SimpleClassNullableOfDateTimeFromJson( + Map json) => + SimpleClassNullableOfDateTime( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + DateTime.parse($jsonValue[r'$1'] as String), + named: DateTime.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassNullableOfDateTimeToJson( + SimpleClassNullableOfDateTime instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1.toIso8601String(), + 'named': instance.value!.named.toIso8601String(), + }, + }; + +SimpleClassOfDateTimeNullable _$SimpleClassOfDateTimeNullableFromJson( + Map json) => + SimpleClassOfDateTimeNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] == null + ? null + : DateTime.parse($jsonValue[r'$1'] as String), + named: $jsonValue['named'] == null + ? null + : DateTime.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassOfDateTimeNullableToJson( + SimpleClassOfDateTimeNullable instance) => + { + 'value': { + r'$1': instance.value.$1?.toIso8601String(), + 'named': instance.value.named?.toIso8601String(), + }, + }; + +SimpleClassNullableOfDateTimeNullable + _$SimpleClassNullableOfDateTimeNullableFromJson( + Map json) => + SimpleClassNullableOfDateTimeNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] == null + ? null + : DateTime.parse($jsonValue[r'$1'] as String), + named: $jsonValue['named'] == null + ? null + : DateTime.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassNullableOfDateTimeNullableToJson( + SimpleClassNullableOfDateTimeNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1?.toIso8601String(), + 'named': instance.value!.named?.toIso8601String(), + }, + }; + +SimpleClassOfDouble _$SimpleClassOfDoubleFromJson(Map json) => + SimpleClassOfDouble( + _$recordConvert( + json['value'], + ($jsonValue) => ( + ($jsonValue[r'$1'] as num).toDouble(), + named: ($jsonValue['named'] as num).toDouble(), + ), + ), + ); + +Map _$SimpleClassOfDoubleToJson( + SimpleClassOfDouble instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfDouble _$SimpleClassNullableOfDoubleFromJson( + Map json) => + SimpleClassNullableOfDouble( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + ($jsonValue[r'$1'] as num).toDouble(), + named: ($jsonValue['named'] as num).toDouble(), + ), + ), + ); + +Map _$SimpleClassNullableOfDoubleToJson( + SimpleClassNullableOfDouble instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfDoubleNullable _$SimpleClassOfDoubleNullableFromJson( + Map json) => + SimpleClassOfDoubleNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + ($jsonValue[r'$1'] as num?)?.toDouble(), + named: ($jsonValue['named'] as num?)?.toDouble(), + ), + ), + ); + +Map _$SimpleClassOfDoubleNullableToJson( + SimpleClassOfDoubleNullable instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfDoubleNullable + _$SimpleClassNullableOfDoubleNullableFromJson(Map json) => + SimpleClassNullableOfDoubleNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + ($jsonValue[r'$1'] as num?)?.toDouble(), + named: ($jsonValue['named'] as num?)?.toDouble(), + ), + ), + ); + +Map _$SimpleClassNullableOfDoubleNullableToJson( + SimpleClassNullableOfDoubleNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfDuration _$SimpleClassOfDurationFromJson( + Map json) => + SimpleClassOfDuration( + _$recordConvert( + json['value'], + ($jsonValue) => ( + Duration(microseconds: $jsonValue[r'$1'] as int), + named: Duration(microseconds: $jsonValue['named'] as int), + ), + ), + ); + +Map _$SimpleClassOfDurationToJson( + SimpleClassOfDuration instance) => + { + 'value': { + r'$1': instance.value.$1.inMicroseconds, + 'named': instance.value.named.inMicroseconds, + }, + }; + +SimpleClassNullableOfDuration _$SimpleClassNullableOfDurationFromJson( + Map json) => + SimpleClassNullableOfDuration( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + Duration(microseconds: $jsonValue[r'$1'] as int), + named: Duration(microseconds: $jsonValue['named'] as int), + ), + ), + ); + +Map _$SimpleClassNullableOfDurationToJson( + SimpleClassNullableOfDuration instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1.inMicroseconds, + 'named': instance.value!.named.inMicroseconds, + }, + }; + +SimpleClassOfDurationNullable _$SimpleClassOfDurationNullableFromJson( + Map json) => + SimpleClassOfDurationNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] == null + ? null + : Duration(microseconds: $jsonValue[r'$1'] as int), + named: $jsonValue['named'] == null + ? null + : Duration(microseconds: $jsonValue['named'] as int), + ), + ), + ); + +Map _$SimpleClassOfDurationNullableToJson( + SimpleClassOfDurationNullable instance) => + { + 'value': { + r'$1': instance.value.$1?.inMicroseconds, + 'named': instance.value.named?.inMicroseconds, + }, + }; + +SimpleClassNullableOfDurationNullable + _$SimpleClassNullableOfDurationNullableFromJson( + Map json) => + SimpleClassNullableOfDurationNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] == null + ? null + : Duration(microseconds: $jsonValue[r'$1'] as int), + named: $jsonValue['named'] == null + ? null + : Duration(microseconds: $jsonValue['named'] as int), + ), + ), + ); + +Map _$SimpleClassNullableOfDurationNullableToJson( + SimpleClassNullableOfDurationNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1?.inMicroseconds, + 'named': instance.value!.named?.inMicroseconds, + }, + }; + +SimpleClassOfDynamic _$SimpleClassOfDynamicFromJson( + Map json) => + SimpleClassOfDynamic( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'], + named: $jsonValue['named'], + ), + ), + ); + +Map _$SimpleClassOfDynamicToJson( + SimpleClassOfDynamic instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfDynamic _$SimpleClassNullableOfDynamicFromJson( + Map json) => + SimpleClassNullableOfDynamic( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'], + named: $jsonValue['named'], + ), + ), + ); + +Map _$SimpleClassNullableOfDynamicToJson( + SimpleClassNullableOfDynamic instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfEnumType _$SimpleClassOfEnumTypeFromJson( + Map json) => + SimpleClassOfEnumType( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $enumDecode(_$EnumTypeEnumMap, $jsonValue[r'$1']), + named: $enumDecode(_$EnumTypeEnumMap, $jsonValue['named']), + ), + ), + ); + +Map _$SimpleClassOfEnumTypeToJson( + SimpleClassOfEnumType instance) => + { + 'value': { + r'$1': _$EnumTypeEnumMap[instance.value.$1]!, + 'named': _$EnumTypeEnumMap[instance.value.named]!, + }, + }; + +const _$EnumTypeEnumMap = { + EnumType.alpha: 'alpha', + EnumType.beta: 'beta', + EnumType.gamma: 'gamma', + EnumType.delta: 'delta', +}; + +SimpleClassNullableOfEnumType _$SimpleClassNullableOfEnumTypeFromJson( + Map json) => + SimpleClassNullableOfEnumType( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $enumDecode(_$EnumTypeEnumMap, $jsonValue[r'$1']), + named: $enumDecode(_$EnumTypeEnumMap, $jsonValue['named']), + ), + ), + ); + +Map _$SimpleClassNullableOfEnumTypeToJson( + SimpleClassNullableOfEnumType instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': _$EnumTypeEnumMap[instance.value!.$1]!, + 'named': _$EnumTypeEnumMap[instance.value!.named]!, + }, + }; + +SimpleClassOfEnumTypeNullable _$SimpleClassOfEnumTypeNullableFromJson( + Map json) => + SimpleClassOfEnumTypeNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $enumDecodeNullable(_$EnumTypeEnumMap, $jsonValue[r'$1']), + named: $enumDecodeNullable(_$EnumTypeEnumMap, $jsonValue['named']), + ), + ), + ); + +Map _$SimpleClassOfEnumTypeNullableToJson( + SimpleClassOfEnumTypeNullable instance) => + { + 'value': { + r'$1': _$EnumTypeEnumMap[instance.value.$1], + 'named': _$EnumTypeEnumMap[instance.value.named], + }, + }; + +SimpleClassNullableOfEnumTypeNullable + _$SimpleClassNullableOfEnumTypeNullableFromJson( + Map json) => + SimpleClassNullableOfEnumTypeNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $enumDecodeNullable(_$EnumTypeEnumMap, $jsonValue[r'$1']), + named: + $enumDecodeNullable(_$EnumTypeEnumMap, $jsonValue['named']), + ), + ), + ); + +Map _$SimpleClassNullableOfEnumTypeNullableToJson( + SimpleClassNullableOfEnumTypeNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': _$EnumTypeEnumMap[instance.value!.$1], + 'named': _$EnumTypeEnumMap[instance.value!.named], + }, + }; + +SimpleClassOfFromJsonDynamicParam _$SimpleClassOfFromJsonDynamicParamFromJson( + Map json) => + SimpleClassOfFromJsonDynamicParam( + _$recordConvert( + json['value'], + ($jsonValue) => ( + FromJsonDynamicParam.fromJson($jsonValue[r'$1']), + named: FromJsonDynamicParam.fromJson($jsonValue['named']), + ), + ), + ); + +Map _$SimpleClassOfFromJsonDynamicParamToJson( + SimpleClassOfFromJsonDynamicParam instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfFromJsonDynamicParam + _$SimpleClassNullableOfFromJsonDynamicParamFromJson( + Map json) => + SimpleClassNullableOfFromJsonDynamicParam( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + FromJsonDynamicParam.fromJson($jsonValue[r'$1']), + named: FromJsonDynamicParam.fromJson($jsonValue['named']), + ), + ), + ); + +Map _$SimpleClassNullableOfFromJsonDynamicParamToJson( + SimpleClassNullableOfFromJsonDynamicParam instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfFromJsonNullableObjectParam + _$SimpleClassOfFromJsonNullableObjectParamFromJson( + Map json) => + SimpleClassOfFromJsonNullableObjectParam( + _$recordConvert( + json['value'], + ($jsonValue) => ( + FromJsonNullableObjectParam.fromJson($jsonValue[r'$1']), + named: FromJsonNullableObjectParam.fromJson($jsonValue['named']), + ), + ), + ); + +Map _$SimpleClassOfFromJsonNullableObjectParamToJson( + SimpleClassOfFromJsonNullableObjectParam instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfFromJsonNullableObjectParam + _$SimpleClassNullableOfFromJsonNullableObjectParamFromJson( + Map json) => + SimpleClassNullableOfFromJsonNullableObjectParam( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + FromJsonNullableObjectParam.fromJson($jsonValue[r'$1']), + named: FromJsonNullableObjectParam.fromJson($jsonValue['named']), + ), + ), + ); + +Map _$SimpleClassNullableOfFromJsonNullableObjectParamToJson( + SimpleClassNullableOfFromJsonNullableObjectParam instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfFromJsonObjectParam _$SimpleClassOfFromJsonObjectParamFromJson( + Map json) => + SimpleClassOfFromJsonObjectParam( + _$recordConvert( + json['value'], + ($jsonValue) => ( + FromJsonObjectParam.fromJson($jsonValue[r'$1'] as Object), + named: FromJsonObjectParam.fromJson($jsonValue['named'] as Object), + ), + ), + ); + +Map _$SimpleClassOfFromJsonObjectParamToJson( + SimpleClassOfFromJsonObjectParam instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfFromJsonObjectParam + _$SimpleClassNullableOfFromJsonObjectParamFromJson( + Map json) => + SimpleClassNullableOfFromJsonObjectParam( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + FromJsonObjectParam.fromJson($jsonValue[r'$1'] as Object), + named: + FromJsonObjectParam.fromJson($jsonValue['named'] as Object), + ), + ), + ); + +Map _$SimpleClassNullableOfFromJsonObjectParamToJson( + SimpleClassNullableOfFromJsonObjectParam instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfInt _$SimpleClassOfIntFromJson(Map json) => + SimpleClassOfInt( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as int, + named: $jsonValue['named'] as int, + ), + ), + ); + +Map _$SimpleClassOfIntToJson(SimpleClassOfInt instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfInt _$SimpleClassNullableOfIntFromJson( + Map json) => + SimpleClassNullableOfInt( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as int, + named: $jsonValue['named'] as int, + ), + ), + ); + +Map _$SimpleClassNullableOfIntToJson( + SimpleClassNullableOfInt instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfIntNullable _$SimpleClassOfIntNullableFromJson( + Map json) => + SimpleClassOfIntNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as int?, + named: $jsonValue['named'] as int?, + ), + ), + ); + +Map _$SimpleClassOfIntNullableToJson( + SimpleClassOfIntNullable instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfIntNullable _$SimpleClassNullableOfIntNullableFromJson( + Map json) => + SimpleClassNullableOfIntNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as int?, + named: $jsonValue['named'] as int?, + ), + ), + ); + +Map _$SimpleClassNullableOfIntNullableToJson( + SimpleClassNullableOfIntNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfNum _$SimpleClassOfNumFromJson(Map json) => + SimpleClassOfNum( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as num, + named: $jsonValue['named'] as num, + ), + ), + ); + +Map _$SimpleClassOfNumToJson(SimpleClassOfNum instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfNum _$SimpleClassNullableOfNumFromJson( + Map json) => + SimpleClassNullableOfNum( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as num, + named: $jsonValue['named'] as num, + ), + ), + ); + +Map _$SimpleClassNullableOfNumToJson( + SimpleClassNullableOfNum instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfNumNullable _$SimpleClassOfNumNullableFromJson( + Map json) => + SimpleClassOfNumNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as num?, + named: $jsonValue['named'] as num?, + ), + ), + ); + +Map _$SimpleClassOfNumNullableToJson( + SimpleClassOfNumNullable instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfNumNullable _$SimpleClassNullableOfNumNullableFromJson( + Map json) => + SimpleClassNullableOfNumNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as num?, + named: $jsonValue['named'] as num?, + ), + ), + ); + +Map _$SimpleClassNullableOfNumNullableToJson( + SimpleClassNullableOfNumNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfObject _$SimpleClassOfObjectFromJson(Map json) => + SimpleClassOfObject( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as Object, + named: $jsonValue['named'] as Object, + ), + ), + ); + +Map _$SimpleClassOfObjectToJson( + SimpleClassOfObject instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfObject _$SimpleClassNullableOfObjectFromJson( + Map json) => + SimpleClassNullableOfObject( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as Object, + named: $jsonValue['named'] as Object, + ), + ), + ); + +Map _$SimpleClassNullableOfObjectToJson( + SimpleClassNullableOfObject instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfObjectNullable _$SimpleClassOfObjectNullableFromJson( + Map json) => + SimpleClassOfObjectNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'], + named: $jsonValue['named'], + ), + ), + ); + +Map _$SimpleClassOfObjectNullableToJson( + SimpleClassOfObjectNullable instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfObjectNullable + _$SimpleClassNullableOfObjectNullableFromJson(Map json) => + SimpleClassNullableOfObjectNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'], + named: $jsonValue['named'], + ), + ), + ); + +Map _$SimpleClassNullableOfObjectNullableToJson( + SimpleClassNullableOfObjectNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfString _$SimpleClassOfStringFromJson(Map json) => + SimpleClassOfString( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as String, + named: $jsonValue['named'] as String, + ), + ), + ); + +Map _$SimpleClassOfStringToJson( + SimpleClassOfString instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfString _$SimpleClassNullableOfStringFromJson( + Map json) => + SimpleClassNullableOfString( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as String, + named: $jsonValue['named'] as String, + ), + ), + ); + +Map _$SimpleClassNullableOfStringToJson( + SimpleClassNullableOfString instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfStringNullable _$SimpleClassOfStringNullableFromJson( + Map json) => + SimpleClassOfStringNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as String?, + named: $jsonValue['named'] as String?, + ), + ), + ); + +Map _$SimpleClassOfStringNullableToJson( + SimpleClassOfStringNullable instance) => + { + 'value': { + r'$1': instance.value.$1, + 'named': instance.value.named, + }, + }; + +SimpleClassNullableOfStringNullable + _$SimpleClassNullableOfStringNullableFromJson(Map json) => + SimpleClassNullableOfStringNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] as String?, + named: $jsonValue['named'] as String?, + ), + ), + ); + +Map _$SimpleClassNullableOfStringNullableToJson( + SimpleClassNullableOfStringNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1, + 'named': instance.value!.named, + }, + }; + +SimpleClassOfUri _$SimpleClassOfUriFromJson(Map json) => + SimpleClassOfUri( + _$recordConvert( + json['value'], + ($jsonValue) => ( + Uri.parse($jsonValue[r'$1'] as String), + named: Uri.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassOfUriToJson(SimpleClassOfUri instance) => + { + 'value': { + r'$1': instance.value.$1.toString(), + 'named': instance.value.named.toString(), + }, + }; + +SimpleClassNullableOfUri _$SimpleClassNullableOfUriFromJson( + Map json) => + SimpleClassNullableOfUri( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + Uri.parse($jsonValue[r'$1'] as String), + named: Uri.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassNullableOfUriToJson( + SimpleClassNullableOfUri instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1.toString(), + 'named': instance.value!.named.toString(), + }, + }; + +SimpleClassOfUriNullable _$SimpleClassOfUriNullableFromJson( + Map json) => + SimpleClassOfUriNullable( + _$recordConvert( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] == null + ? null + : Uri.parse($jsonValue[r'$1'] as String), + named: $jsonValue['named'] == null + ? null + : Uri.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassOfUriNullableToJson( + SimpleClassOfUriNullable instance) => + { + 'value': { + r'$1': instance.value.$1?.toString(), + 'named': instance.value.named?.toString(), + }, + }; + +SimpleClassNullableOfUriNullable _$SimpleClassNullableOfUriNullableFromJson( + Map json) => + SimpleClassNullableOfUriNullable( + _$recordConvertNullable( + json['value'], + ($jsonValue) => ( + $jsonValue[r'$1'] == null + ? null + : Uri.parse($jsonValue[r'$1'] as String), + named: $jsonValue['named'] == null + ? null + : Uri.parse($jsonValue['named'] as String), + ), + ), + ); + +Map _$SimpleClassNullableOfUriNullableToJson( + SimpleClassNullableOfUriNullable instance) => + { + 'value': instance.value == null + ? null + : { + r'$1': instance.value!.$1?.toString(), + 'named': instance.value!.named?.toString(), + }, + }; diff --git a/json_serializable/tool/test_type_builder.dart b/json_serializable/tool/test_type_builder.dart index e35dfd766..31f96c3ba 100644 --- a/json_serializable/tool/test_type_builder.dart +++ b/json_serializable/tool/test_type_builder.dart @@ -59,7 +59,7 @@ const _trivialTypesToTest = { ), }; -Iterable supportedTypes() => _typesToTest.keys; +Iterable supportedTypes() => _allTypes.keys; Iterable collectionTypes() => _collectionTypes.keys; @@ -87,13 +87,19 @@ final _collectionTypes = { altJsonExpression: '[$_altCollectionExpressions]', genericArgs: _iterableGenericArgs, ), + recordType: TestTypeData( + altJsonExpression: '{}', + genericArgs: _iterableGenericArgs, + ) }; -final _typesToTest = { +final _allTypes = { ..._trivialTypesToTest, ..._collectionTypes, }; +final _typesToTest = Map.of(_allTypes)..remove(recordType); + Iterable get mapKeyTypes => allowedMapKeyTypes.map((e) => e == 'enum' ? customEnumType : e).toList() ..sort(compareAsciiLowerCase); @@ -122,7 +128,7 @@ class _TypeBuilder implements Builder { final sourceContent = await buildStep.readAsString(inputId); - for (var entry in _typesToTest.entries) { + for (var entry in _allTypes.entries) { final type = entry.key; final newId = buildStep.inputId.changeExtension(toTypeExtension(type)); @@ -134,9 +140,8 @@ class _TypeBuilder implements Builder { } @override - Map> get buildExtensions => { - '.dart': _typesToTest.keys.map(toTypeExtension).toSet().toList()..sort() - }; + Map> get buildExtensions => + {'.dart': _allTypes.keys.map(toTypeExtension).toSet().toList()..sort()}; } Builder typeTestBuilder([_]) => diff --git a/json_serializable/tool/test_type_data.dart b/json_serializable/tool/test_type_data.dart index f6042fe9c..3b6366d00 100644 --- a/json_serializable/tool/test_type_data.dart +++ b/json_serializable/tool/test_type_data.dart @@ -2,6 +2,8 @@ import 'shared.dart'; const customEnumType = 'EnumType'; +const recordType = 'Record'; + const _annotationImport = "import 'package:json_annotation/json_annotation.dart';"; @@ -56,13 +58,19 @@ class TestTypeData { final buffer = StringBuffer(Replacement.generate(split[0], headerReplacements)); + if (type == recordType) { + buffer.writeln('typedef RecordTypeDef = ();'); + } + final simpleClassContent = '$classAnnotationSplit${split[1]}'; + final simpleLiteral = type == recordType ? 'RecordTypeDef' : type; + buffer ..write( Replacement.generate( simpleClassContent, - _libReplacements(type), + _libReplacements(simpleLiteral), ), ) ..write( @@ -71,21 +79,30 @@ class TestTypeData { 'SimpleClass', 'SimpleClassNullable', ), - _libReplacements('$type?'), + _libReplacements('$simpleLiteral?'), ), ); for (var genericArg in genericArgs) { final genericArgClassPart = _genericClassPart(genericArg); - final genericType = '$type<$genericArg>'; + final theName = 'SimpleClassOf$genericArgClassPart'; + + final genericType = + type == recordType ? '${theName}TypeDef' : '$type<$genericArg>'; + + if (type == recordType) { + buffer.writeln( + 'typedef $genericType = ($genericArg, {$genericArg named});', + ); + } buffer ..write( Replacement.generate( simpleClassContent.replaceAll( 'SimpleClass', - 'SimpleClassOf$genericArgClassPart', + theName, ), _libReplacements(genericType), ),