+
+ Line data Source code
+
+ 1 : import 'dart:convert';
+ 2 :
+ 3 : typedef Any = Object?;
+ 4 :
+ 5 : /// Wraps Json decoded data
+ 6 : class Json {
+ 7 : static const decoder = JsonDecoder();
+ 8 :
+ 9 : Any _rawValue;
+ 10 :
+ 11 : /// Actual value
+ 12 2 : Any get rawValue => _rawValue;
+ 13 :
+ 14 : /// Exceptions are never thrown, instead they are silently stored in the [Json] instance
+ 15 : JsonException? exception;
+ 16 :
+ 17 : /// Empty [Json]
+ 18 1 : Json();
+ 19 :
+ 20 : /// Decodes the string with [JsonDecoder] and wraps it with [Json]
+ 21 2 : Json.fromString(String json) : _rawValue = Json.decoder.convert(json);
+ 22 :
+ 23 : /// Create a [Json] instance from any value
+ 24 1 : Json.fromDynamic(this._rawValue, {bool initial = true}) {
+ 25 : if (!initial) {
+ 26 : // Type checking has already been done
+ 27 : return;
+ 28 : }
+ 29 :
+ 30 2 : final asMap = tryCast<Map<String, Any>>(_rawValue);
+ 31 2 : final asIterable = tryCast<Iterable<Any>>(_rawValue);
+ 32 :
+ 33 : if (asMap != null) {
+ 34 2 : _rawValue = <String, Any>{};
+ 35 2 : asMap.forEach((String key, Any value) {
+ 36 : try {
+ 37 1 : _set(key, value);
+ 38 1 : } on JsonException catch (error) {
+ 39 2 : exception = exception ?? error;
+ 40 : }
+ 41 : });
+ 42 : } else if (asIterable != null) {
+ 43 2 : _rawValue = <Any>[];
+ 44 : int i = 0;
+ 45 2 : for (final item in asIterable) {
+ 46 : try {
+ 47 2 : _set(i++, item);
+ 48 1 : } on JsonException catch (error) {
+ 49 2 : exception = exception ?? error;
+ 50 1 : i--;
+ 51 : }
+ 52 : }
+ 53 2 : } else if (_rawValue is! int &&
+ 54 2 : _rawValue is! double &&
+ 55 2 : _rawValue is! String &&
+ 56 1 : _rawValue != null &&
+ 57 2 : _rawValue is! bool) {
+ 58 3 : exception = exception ?? JsonException(JsonError.unsupportedType);
+ 59 1 : _rawValue = null;
+ 60 : }
+ 61 : }
+ 62 :
+ 63 : /// Create [Json] from a [Map]
+ 64 1 : Json.fromMap(Map<String, Any> map) {
+ 65 2 : _rawValue = <String, Any>{};
+ 66 :
+ 67 2 : map.forEach((String key, Any value) {
+ 68 : try {
+ 69 1 : _set(key, value);
+ 70 1 : } on JsonException catch (error) {
+ 71 2 : exception = exception ?? error;
+ 72 : }
+ 73 : });
+ 74 : }
+ 75 :
+ 76 : /// Create [Json] from a [List]
+ 77 1 : Json.fromList(List<Any> list) {
+ 78 2 : _rawValue = <Any>[];
+ 79 :
+ 80 : int i = 0;
+ 81 2 : for (var item in list) {
+ 82 : try {
+ 83 2 : _set(i++, item);
+ 84 1 : } on JsonException catch (error) {
+ 85 2 : exception = exception ?? error;
+ 86 1 : i--;
+ 87 : }
+ 88 : }
+ 89 : }
+ 90 :
+ 91 : /// Create [Json] from another
+ 92 1 : Json.from(Json other, {bool initial = true}) {
+ 93 : if (!initial) {
+ 94 2 : _rawValue = other._rawValue;
+ 95 : return;
+ 96 : }
+ 97 :
+ 98 3 : assert(other._rawValue is int ||
+ 99 2 : other._rawValue is double ||
+ 100 2 : other._rawValue is bool ||
+ 101 2 : other._rawValue is String ||
+ 102 1 : other._rawValue == null ||
+ 103 2 : other._rawValue is Map ||
+ 104 2 : other._rawValue is List);
+ 105 :
+ 106 2 : if (other._rawValue is int ||
+ 107 2 : other._rawValue is double ||
+ 108 2 : other._rawValue is bool ||
+ 109 2 : other._rawValue is String ||
+ 110 1 : other._rawValue == null) {
+ 111 2 : _rawValue = other._rawValue;
+ 112 2 : } else if (other._rawValue is Map) {
+ 113 3 : _rawValue = Map<String, Any>.from(other._rawValue as Map);
+ 114 2 : } else if (other._rawValue is List) {
+ 115 3 : _rawValue = List<Any>.from(other._rawValue as List);
+ 116 : }
+ 117 :
+ 118 2 : exception = other.exception;
+ 119 : }
+ 120 :
+ 121 : /// Create a [Json] with a [null] [rawValue]
+ 122 2 : Json get jsonNull => Json.fromDynamic(null);
+ 123 :
+ 124 : /// Returns actual Json
+ 125 1 : @override
+ 126 2 : String toString() => jsonEncode(_rawValue);
+ 127 :
+ 128 : /// Compare [Json] by instance or by value
+ 129 1 : @override
+ 130 : bool operator ==(Object other) =>
+ 131 4 : identical(this, other) || other is Json && toString() == other.toString();
+ 132 :
+ 133 1 : @override
+ 134 2 : int get hashCode => toString().hashCode;
+ 135 :
+ 136 1 : void _set(Any key, Any value) {
+ 137 : // If not a json encodable type fail
+ 138 1 : if (value is! String &&
+ 139 1 : value is! int &&
+ 140 1 : value is! double &&
+ 141 1 : value is! bool &&
+ 142 1 : value is! List &&
+ 143 1 : value is! Map &&
+ 144 : value != null) {
+ 145 1 : throw JsonException(JsonError.unsupportedType);
+ 146 : }
+ 147 :
+ 148 : if (key == null) return;
+ 149 :
+ 150 2 : final rawMap = tryCast<Map<Any, Any>>(_rawValue);
+ 151 2 : final rawList = tryCast<List<Any>>(_rawValue);
+ 152 : if (rawList != null) {
+ 153 3 : int? index = (key is String) ? int.tryParse(key) : tryCast<int>(key);
+ 154 : if (index == null) {
+ 155 1 : throw JsonException(
+ 156 : JsonError.wrongType,
+ 157 2 : userReason: 'JSON Error: index must be int, ${key.runtimeType} given',
+ 158 : );
+ 159 : }
+ 160 :
+ 161 3 : if (index < 0 || index > rawList.length) {
+ 162 1 : throw JsonException(
+ 163 : JsonError.indexOutOfBounds,
+ 164 1 : userReason: 'JSON Error: index `$index` is out of bounds',
+ 165 : );
+ 166 2 : } else if (index == rawList.length) {
+ 167 1 : rawList.add(value);
+ 168 : } else {
+ 169 1 : rawList[index] = value;
+ 170 : }
+ 171 : } else if (rawMap != null) {
+ 172 2 : rawMap[key.toString()] = value;
+ 173 : }
+ 174 : }
+ 175 :
+ 176 : /// Returns a [Json] wrapping the data under [key]. If [key] does not exist, returns a empty [Json] instance with an [exception]
+ 177 1 : Json operator [](Object key) {
+ 178 2 : if ((key is! String && key is! int) ||
+ 179 4 : (_rawValue is! List && _rawValue is! Map)) {
+ 180 1 : var result = jsonNull;
+ 181 3 : result.exception = exception ?? JsonException(JsonError.wrongType);
+ 182 : return result;
+ 183 : }
+ 184 :
+ 185 2 : final rawList = tryCast<List<Any>>(_rawValue);
+ 186 2 : final rawMap = tryCast<Map<Any, Any>>(_rawValue);
+ 187 :
+ 188 : if (rawList != null) {
+ 189 3 : int? index = key is String ? int.tryParse(key) : tryCast<int>(key);
+ 190 :
+ 191 : if (index == null) {
+ 192 1 : var result = jsonNull;
+ 193 2 : result.exception = exception ??
+ 194 1 : JsonException(
+ 195 : JsonError.wrongType,
+ 196 : userReason:
+ 197 2 : 'JSON Error: index must be int, ${key.runtimeType} given',
+ 198 : );
+ 199 : return result;
+ 200 : }
+ 201 :
+ 202 3 : if (index < 0 || index >= rawList.length) {
+ 203 1 : var result = jsonNull;
+ 204 2 : result.exception = exception ??
+ 205 1 : JsonException(
+ 206 : JsonError.indexOutOfBounds,
+ 207 1 : userReason: 'JSON Error: index `$index` is out of bounds',
+ 208 : );
+ 209 : return result;
+ 210 : }
+ 211 :
+ 212 2 : return Json.fromDynamic(rawList.elementAtOrNull(index), initial: false);
+ 213 : }
+ 214 :
+ 215 1 : assert(rawMap != null);
+ 216 :
+ 217 1 : final index = key.toString();
+ 218 2 : final result = Json.fromDynamic(rawMap![index], initial: false);
+ 219 1 : if (!rawMap.containsKey(index)) {
+ 220 2 : result.exception = exception ??
+ 221 1 : JsonException(
+ 222 : JsonError.notExist,
+ 223 1 : userReason: 'JSON Error: key `$index` does not exists',
+ 224 : );
+ 225 : }
+ 226 :
+ 227 : return result;
+ 228 : }
+ 229 :
+ 230 : /// Returns [true] if [exception] is [null]
+ 231 1 : bool exists([Any key]) {
+ 232 : return key != null
+ 233 4 : ? this[key].exception == null && this[key].rawValue != null
+ 234 2 : : exception == null && rawValue != null;
+ 235 : }
+ 236 :
+ 237 : /// Returns a [String] or [null] if [rawValue] is not a [String]
+ 238 4 : String? get string => (_rawValue is String) ? _rawValue as String : null;
+ 239 :
+ 240 : /// Returns a [String] or an empty [String] if [rawValue] is not a [String]
+ 241 3 : String get stringValue => _rawValue is String ||
+ 242 2 : _rawValue is bool ||
+ 243 2 : _rawValue is int ||
+ 244 2 : _rawValue is double
+ 245 2 : ? _rawValue?.toString() ?? ''
+ 246 : : '';
+ 247 :
+ 248 : /// Returns a [bool] or [null] if [rawValue] is not a [bool]
+ 249 4 : bool? get boolean => (_rawValue is bool) ? _rawValue as bool : null;
+ 250 :
+ 251 : /// Returns a [bool] or [false] if [rawValue] is not thruthy
+ 252 1 : bool get booleanValue {
+ 253 2 : if (_rawValue is bool) {
+ 254 1 : return _rawValue as bool;
+ 255 4 : } else if (_rawValue is int || _rawValue is double) {
+ 256 2 : return _rawValue == 1;
+ 257 2 : } else if (_rawValue is String) {
+ 258 1 : return ['true', 'y', 't', 'yes', '1']
+ 259 3 : .contains((_rawValue as String).toLowerCase());
+ 260 : }
+ 261 :
+ 262 : return false;
+ 263 : }
+ 264 :
+ 265 : /// Returns a [int] or [null] if [rawValue] is not a [int]
+ 266 4 : int? get integer => (_rawValue is int) ? _rawValue as int : null;
+ 267 :
+ 268 : /// Returns a [int] or 0 if [rawValue] is not a [int]
+ 269 1 : int get integerValue {
+ 270 2 : if (_rawValue is int) {
+ 271 1 : return _rawValue as int;
+ 272 2 : } else if (_rawValue is bool) {
+ 273 1 : return _rawValue as bool ? 1 : 0;
+ 274 2 : } else if (_rawValue is double) {
+ 275 2 : return (_rawValue as double).toInt();
+ 276 2 : } else if (_rawValue is String) {
+ 277 : try {
+ 278 2 : return int.parse(_rawValue as String);
+ 279 : } catch (error) {
+ 280 : return 0;
+ 281 : }
+ 282 : }
+ 283 :
+ 284 : return 0;
+ 285 : }
+ 286 :
+ 287 1 : double? get float =>
+ 288 4 : (_rawValue is num) ? (_rawValue as num).toDouble() : null;
+ 289 :
+ 290 : /// Returns a [double] 0 if [rawValue] is not a [double]
+ 291 1 : double get floatValue {
+ 292 2 : if (_rawValue is double) {
+ 293 1 : return _rawValue as double;
+ 294 2 : } else if (_rawValue is int) {
+ 295 2 : return (_rawValue as int).toDouble();
+ 296 2 : } else if (_rawValue is bool) {
+ 297 1 : return _rawValue as bool ? 1 : 0;
+ 298 2 : } else if (_rawValue is String) {
+ 299 : try {
+ 300 2 : return double.parse(_rawValue as String);
+ 301 : } catch (error) {
+ 302 : return 0;
+ 303 : }
+ 304 : }
+ 305 :
+ 306 : return 0;
+ 307 : }
+ 308 :
+ 309 : /// Returns a [T] or [null] if [rawValue] is not a [T]
+ 310 : /// If actual data is not [T], calls [builder] to get one
+ 311 1 : T? ofType<T>([T? Function(Json)? builder]) {
+ 312 2 : if (_rawValue is T) {
+ 313 1 : return _rawValue as T;
+ 314 : } else if (builder != null) {
+ 315 1 : return builder(this);
+ 316 : }
+ 317 :
+ 318 : return null;
+ 319 : }
+ 320 :
+ 321 : /// Returns a [T] or [defaultValue] if [rawValue] is not a [T]
+ 322 : /// If actual data is not [T], calls [builder] to get one
+ 323 1 : T ofTypeValue<T>(T defaultValue, [T? Function(Json)? builder]) {
+ 324 2 : if (_rawValue is T) {
+ 325 1 : return _rawValue as T;
+ 326 : } else if (builder != null) {
+ 327 1 : T? built = builder(this);
+ 328 :
+ 329 : if (built != null) {
+ 330 : return built;
+ 331 : }
+ 332 : }
+ 333 :
+ 334 : return defaultValue;
+ 335 : }
+ 336 :
+ 337 : /// Returns a [List] or [null] if [rawValue] is not a [List]
+ 338 : /// Each element of the list is wrapped in a [Json] instance
+ 339 3 : List<Json>? get list => (_rawValue is List)
+ 340 5 : ? (_rawValue as List).map<Json>((Any e) => Json.fromDynamic(e)).toList()
+ 341 : : null;
+ 342 :
+ 343 : /// Returns a [List] or an empty [List] if [rawValue] is not a [List]
+ 344 : /// Each element of the list is wrapped in a [Json] instance
+ 345 3 : List<Json> get listValue => (_rawValue is List)
+ 346 5 : ? (_rawValue as List).map<Json>((Any e) => Json.fromDynamic(e)).toList()
+ 347 0 : : [];
+ 348 :
+ 349 : /// Returns a [List] or [null] if [rawValue] is not a [List]
+ 350 : /// Leaves list items untouched
+ 351 4 : List<Any>? get listObject => (_rawValue is List) ? _rawValue as List : null;
+ 352 :
+ 353 : /// Returns a [List] or an empty [List] if [rawValue] is not a [List]
+ 354 : /// Leaves list items untouched
+ 355 5 : List<Any> get listObjectValue => (_rawValue is List) ? _rawValue as List : [];
+ 356 :
+ 357 : /// Returns a [List] of [T] or empty list if [rawValue] is not a [List] of [T]
+ 358 : /// If actual data is not a [List] of [T], calls [builder] to get one
+ 359 1 : List<T>? listOf<T>([T? Function(Json)? builder]) {
+ 360 2 : if (_rawValue is List) {
+ 361 1 : return (_rawValue as List)
+ 362 2 : .map<T?>((Any e) {
+ 363 1 : if (e is T) {
+ 364 : return e;
+ 365 : } else if (builder != null) {
+ 366 2 : return builder(Json.fromDynamic(e));
+ 367 : }
+ 368 :
+ 369 : return null;
+ 370 : })
+ 371 1 : .whereType<T>()
+ 372 1 : .toList();
+ 373 : }
+ 374 :
+ 375 : return null;
+ 376 : }
+ 377 :
+ 378 : /// Returns a [List] of [T] or an empty [List] if [rawValue] is not a [List] of [T]
+ 379 : /// If actual data is not a [List] of [T], calls [builder] to get one
+ 380 1 : List<T> listOfValue<T>([T? Function(Json)? builder]) {
+ 381 1 : return listOf(builder) ?? [];
+ 382 : }
+ 383 :
+ 384 : /// Returns a [Map] or [null] if [rawValue] is not a [Map]
+ 385 : /// Each value of the map is wrapped in a [Json]
+ 386 3 : Map<String, Json>? get map => (_rawValue is Map)
+ 387 2 : ? (_rawValue as Map).map(
+ 388 4 : (Any key, Any value) => MapEntry('$key', Json.fromDynamic(value)),
+ 389 : )
+ 390 : : null;
+ 391 :
+ 392 : /// Returns a [Map] or an empty [Map] if [rawValue] is not a [Map]
+ 393 : /// Each value of the map is wrapped in a [Json]
+ 394 3 : Map<String, Json> get mapValue => (_rawValue is Map)
+ 395 2 : ? (_rawValue as Map).map(
+ 396 4 : (Any key, Any value) => MapEntry('$key', Json.fromDynamic(value)),
+ 397 : )
+ 398 1 : : {};
+ 399 :
+ 400 : /// Returns a [Map] or [null] if [rawValue] is not a [Map]
+ 401 : /// Leaves map values untouched
+ 402 1 : Map<String, Any>? get mapObject =>
+ 403 3 : (_rawValue is Map) ? _rawValue as Map<String, Any> : null;
+ 404 :
+ 405 : /// Returns a [Map] of [T] or empty [Map] if [rawValue] is not a [Map] of [T]
+ 406 : /// Leaves map values untouched
+ 407 1 : Map<String, Any> get mapObjectValue =>
+ 408 4 : (_rawValue is Map) ? _rawValue as Map<String, Any> : {};
+ 409 :
+ 410 : /// Returns a [Map] of [T] or [null] if [rawValue] is not a [Map] of [T]
+ 411 : /// If actual data is not a [Map] of [T], calls [builder] to get one
+ 412 1 : Map<String, T>? mapOf<T>([T? Function(Json)? builder]) {
+ 413 2 : if (_rawValue is Map) {
+ 414 2 : return <String, T>{}..addEntries(
+ 415 1 : (_rawValue as Map)
+ 416 1 : .entries
+ 417 2 : .map<MapEntry<String, T>?>((entry) {
+ 418 2 : if (entry.key is! String) {
+ 419 : return null;
+ 420 2 : } else if (entry.value is T) {
+ 421 1 : return MapEntry<String, T>(
+ 422 2 : entry.key as String, entry.value as T);
+ 423 : } else if (builder != null) {
+ 424 3 : final element = builder(Json.fromDynamic(entry.value));
+ 425 : if (element != null) {
+ 426 2 : return MapEntry(entry.key as String, element);
+ 427 : }
+ 428 : }
+ 429 :
+ 430 : return null;
+ 431 : })
+ 432 1 : .whereType<MapEntry<String, T>>()
+ 433 1 : .toList(),
+ 434 : );
+ 435 : }
+ 436 :
+ 437 : return null;
+ 438 : }
+ 439 :
+ 440 : /// Returns a [List] of [T] or empty [Map] if [rawValue] is not a [List] of [T]
+ 441 : /// If actual data is not a [List] of [T], calls [builder] to get one
+ 442 1 : Map<String, T> mapOfValue<T>([T? Function(Json)? builder]) {
+ 443 1 : return mapOf(builder) ?? {};
+ 444 : }
+ 445 : }
+ 446 :
+ 447 : /// A mutable Json payload that enforce it'll always be able to json encode it's content
+ 448 : class JsonPayload extends Json {
+ 449 1 : JsonPayload();
+ 450 2 : JsonPayload.fromString(super.json) : super.fromString();
+ 451 1 : JsonPayload.fromDynamic(super.rawValue, {super.initial})
+ 452 1 : : super.fromDynamic();
+ 453 2 : JsonPayload.fromMap(super.map) : super.fromMap();
+ 454 2 : JsonPayload.fromList(super.list) : super.fromList();
+ 455 2 : JsonPayload.from(super.other, {super.initial}) : super.from();
+ 456 :
+ 457 1 : set rawValue(Any newValue) {
+ 458 1 : _rawValue = newValue;
+ 459 : }
+ 460 :
+ 461 1 : void operator []=(Any key, Any value) {
+ 462 4 : if (_rawValue is! List && _rawValue is! Map) {
+ 463 1 : throw JsonException(JsonError.wrongType,
+ 464 : userReason: 'Underlying value is neither a map or a list');
+ 465 : }
+ 466 :
+ 467 1 : _set(key, value);
+ 468 : }
+ 469 :
+ 470 1 : @override
+ 471 1 : JsonPayload get jsonNull => JsonPayload.fromDynamic(null);
+ 472 :
+ 473 1 : @override
+ 474 : JsonPayload operator [](Object key) =>
+ 475 2 : JsonPayload.from(super[key], initial: false);
+ 476 :
+ 477 1 : @override
+ 478 2 : List<JsonPayload>? get list => (_rawValue is List)
+ 479 1 : ? (_rawValue as List)
+ 480 3 : .map<JsonPayload>((Any e) => JsonPayload.fromDynamic(e))
+ 481 1 : .toList()
+ 482 : : null;
+ 483 :
+ 484 1 : @override
+ 485 1 : List<JsonPayload> get listValue => list ?? [];
+ 486 :
+ 487 1 : @override
+ 488 2 : Map<String, JsonPayload>? get map => (_rawValue is Map)
+ 489 3 : ? (_rawValue as Map).map((Any key, Any value) =>
+ 490 3 : MapEntry('$key', JsonPayload.fromDynamic(value)))
+ 491 : : null;
+ 492 :
+ 493 1 : @override
+ 494 1 : Map<String, JsonPayload> get mapValue => map ?? {};
+ 495 :
+ 496 : /// Remove element under [key]
+ 497 1 : void removeElementWithKey(Any key) {
+ 498 2 : if (_rawValue is List) {
+ 499 1 : final rawList = _rawValue as List;
+ 500 : late int index;
+ 501 :
+ 502 1 : if (key is String) {
+ 503 : try {
+ 504 1 : index = int.parse(key);
+ 505 : } catch (_, trace) {
+ 506 1 : Error.throwWithStackTrace(
+ 507 1 : JsonException(
+ 508 : JsonError.wrongType,
+ 509 : userReason:
+ 510 2 : 'JSON Error: index must be int, ${key.runtimeType} given',
+ 511 : ),
+ 512 : trace,
+ 513 : );
+ 514 : }
+ 515 : } else {
+ 516 : index = key as int;
+ 517 : }
+ 518 :
+ 519 3 : if (index < 0 || index > rawList.length) {
+ 520 1 : throw JsonException(
+ 521 : JsonError.indexOutOfBounds,
+ 522 1 : userReason: 'JSON Error: index `$index` is out of bounds',
+ 523 : );
+ 524 : }
+ 525 :
+ 526 1 : rawList.removeAt(index);
+ 527 2 : } else if (_rawValue is Map) {
+ 528 1 : final rawMap = _rawValue as Map;
+ 529 : late String index;
+ 530 :
+ 531 1 : if (key is String) {
+ 532 : index = key;
+ 533 : } else {
+ 534 1 : index = '$key';
+ 535 : }
+ 536 :
+ 537 1 : rawMap.remove(index);
+ 538 : } else {
+ 539 1 : throw throw JsonException(
+ 540 : JsonError.wrongType,
+ 541 : userReason: '_rawValue is not a List or a Map',
+ 542 : );
+ 543 : }
+ 544 : }
+ 545 : }
+ 546 :
+ 547 2 : T? tryCast<T>(Any object) => object is T ? object : null;
+ 548 :
+ 549 : /// Json error types
+ 550 : enum JsonError {
+ 551 : /// Type is not json encodable
+ 552 : unsupportedType(reason: 'JSON Error: not a valid JSON value'),
+ 553 :
+ 554 : /// Out of bound access to list
+ 555 : indexOutOfBounds(reason: 'JSON Error: index out of bounds'),
+ 556 :
+ 557 : /// Unexpected type
+ 558 : wrongType(
+ 559 : reason:
+ 560 : 'JSON Error: either key is not a index type or value is not indexable',
+ 561 : ),
+ 562 :
+ 563 : /// Entry does not exists
+ 564 : notExist(reason: 'JSON Error: key does\'t not exists');
+ 565 :
+ 566 : final String reason;
+ 567 :
+ 568 : const JsonError({required this.reason});
+ 569 : }
+ 570 :
+ 571 : /// Exceptions are never thrown, instead they are silently stored in the [Json] instance
+ 572 : class JsonException implements Exception {
+ 573 : /// What error is this
+ 574 : final JsonError error;
+ 575 :
+ 576 : /// Error message
+ 577 : final String reason;
+ 578 :
+ 579 1 : JsonException(this.error, {String? userReason})
+ 580 1 : : reason = userReason ?? error.reason;
+ 581 :
+ 582 1 : @override
+ 583 3 : String toString() => 'JsonException{error: $error, reason: $reason}';
+ 584 : }
+
+ |
+
+ 
