treewide: dart format

lib/models/jmdict/jmdict_dialect.dart

@@ -19,20 +19,14 @@ enum JMdictDialect {
   final String id;
   final String description;
 
-  const JMdictDialect({
-    required this.id,
-    required this.description,
-  });
+  const JMdictDialect({required this.id, required this.description});
 
   static JMdictDialect fromId(String id) => JMdictDialect.values.firstWhere(
-        (e) => e.id == id,
-        orElse: () => throw Exception('Unknown id: $id'),
-      );
+    (e) => e.id == id,
+    orElse: () => throw Exception('Unknown id: $id'),
+  );
 
-  Map<String, Object?> toJson() => {
-        'id': id,
-        'description': description,
-      };
+  Map<String, Object?> toJson() => {'id': id, 'description': description};
 
   static JMdictDialect fromJson(Map<String, Object?> json) =>
       JMdictDialect.values.firstWhere(

lib/models/jmdict/jmdict_field.dart

@@ -102,20 +102,14 @@ enum JMdictField {
   final String id;
   final String description;
 
-  const JMdictField({
-    required this.id,
-    required this.description,
-  });
+  const JMdictField({required this.id, required this.description});
 
   static JMdictField fromId(String id) => JMdictField.values.firstWhere(
-        (e) => e.id == id,
-        orElse: () => throw Exception('Unknown id: $id'),
-      );
+    (e) => e.id == id,
+    orElse: () => throw Exception('Unknown id: $id'),
+  );
 
-  Map<String, Object?> toJson() => {
-        'id': id,
-        'description': description,
-      };
+  Map<String, Object?> toJson() => {'id': id, 'description': description};
 
   static JMdictField fromJson(Map<String, Object?> json) =>
       JMdictField.values.firstWhere(

lib/models/jmdict/jmdict_kanji_info.dart

@@ -13,20 +13,14 @@ enum JMdictKanjiInfo {
   final String id;
   final String description;
 
-  const JMdictKanjiInfo({
-    required this.id,
-    required this.description,
-  });
+  const JMdictKanjiInfo({required this.id, required this.description});
 
   static JMdictKanjiInfo fromId(String id) => JMdictKanjiInfo.values.firstWhere(
-        (e) => e.id == id,
-        orElse: () => throw Exception('Unknown id: $id'),
-      );
+    (e) => e.id == id,
+    orElse: () => throw Exception('Unknown id: $id'),
+  );
 
-  Map<String, Object?> toJson() => {
-        'id': id,
-        'description': description,
-      };
+  Map<String, Object?> toJson() => {'id': id, 'description': description};
 
   static JMdictKanjiInfo fromJson(Map<String, Object?> json) =>
       JMdictKanjiInfo.values.firstWhere(

lib/models/jmdict/jmdict_misc.dart

@@ -74,20 +74,14 @@ enum JMdictMisc {
   final String id;
   final String description;
 
-  const JMdictMisc({
-    required this.id,
-    required this.description,
-  });
+  const JMdictMisc({required this.id, required this.description});
 
   static JMdictMisc fromId(String id) => JMdictMisc.values.firstWhere(
-        (e) => e.id == id,
-        orElse: () => throw Exception('Unknown id: $id'),
-      );
+    (e) => e.id == id,
+    orElse: () => throw Exception('Unknown id: $id'),
+  );
 
-  Map<String, Object?> toJson() => {
-        'id': id,
-        'description': description,
-      };
+  Map<String, Object?> toJson() => {'id': id, 'description': description};
 
   static JMdictMisc fromJson(Map<String, Object?> json) =>
       JMdictMisc.values.firstWhere(

lib/models/jmdict/jmdict_pos.dart

@@ -202,14 +202,11 @@ enum JMdictPOS {
   String get shortDescription => _shortDescription ?? description;
 
   static JMdictPOS fromId(String id) => JMdictPOS.values.firstWhere(
-        (e) => e.id == id,
-        orElse: () => throw Exception('Unknown id: $id'),
-      );
+    (e) => e.id == id,
+    orElse: () => throw Exception('Unknown id: $id'),
+  );
 
-  Map<String, Object?> toJson() => {
-        'id': id,
-        'description': description,
-      };
+  Map<String, Object?> toJson() => {'id': id, 'description': description};
 
   static JMdictPOS fromJson(Map<String, Object?> json) =>
       JMdictPOS.values.firstWhere(

lib/models/jmdict/jmdict_reading_info.dart

@@ -15,10 +15,7 @@ enum JMdictReadingInfo {
   final String id;
   final String description;
 
-  const JMdictReadingInfo({
-    required this.id,
-    required this.description,
-  });
+  const JMdictReadingInfo({required this.id, required this.description});
 
   static JMdictReadingInfo fromId(String id) =>
       JMdictReadingInfo.values.firstWhere(
@@ -26,10 +23,7 @@ enum JMdictReadingInfo {
         orElse: () => throw Exception('Unknown id: $id'),
       );
 
-  Map<String, Object?> toJson() => {
-        'id': id,
-        'description': description,
-      };
+  Map<String, Object?> toJson() => {'id': id, 'description': description};
 
   static JMdictReadingInfo fromJson(Map<String, Object?> json) =>
       JMdictReadingInfo.values.firstWhere(

lib/models/kanji_search/kanji_search_radical.dart

@@ -26,19 +26,14 @@ class KanjiSearchRadical extends Equatable {
   });
 
   @override
-  List<Object> get props => [
-        symbol,
-        this.names,
-        forms,
-        meanings,
-      ];
+  List<Object> get props => [symbol, this.names, forms, meanings];
 
   Map<String, dynamic> toJson() => {
-        'symbol': symbol,
-        'names': names,
-        'forms': forms,
-        'meanings': meanings,
-      };
+    'symbol': symbol,
+    'names': names,
+    'forms': forms,
+    'meanings': meanings,
+  };
 
   factory KanjiSearchRadical.fromJson(Map<String, dynamic> json) {
     return KanjiSearchRadical(

lib/models/kanji_search/kanji_search_result.dart

@@ -89,46 +89,46 @@ class KanjiSearchResult extends Equatable {
   @override
   // ignore: public_member_api_docs
   List<Object?> get props => [
-        taughtIn,
-        jlptLevel,
-        newspaperFrequencyRank,
-        strokeCount,
-        meanings,
-        kunyomi,
-        onyomi,
-        // kunyomiExamples,
-        // onyomiExamples,
-        radical,
-        parts,
-        codepoints,
-        kanji,
-        nanori,
-        alternativeLanguageReadings,
-        strokeMiscounts,
-        queryCodes,
-        dictionaryReferences,
-      ];
+    taughtIn,
+    jlptLevel,
+    newspaperFrequencyRank,
+    strokeCount,
+    meanings,
+    kunyomi,
+    onyomi,
+    // kunyomiExamples,
+    // onyomiExamples,
+    radical,
+    parts,
+    codepoints,
+    kanji,
+    nanori,
+    alternativeLanguageReadings,
+    strokeMiscounts,
+    queryCodes,
+    dictionaryReferences,
+  ];
 
   Map<String, dynamic> toJson() => {
-        'kanji': kanji,
-        'taughtIn': taughtIn,
-        'jlptLevel': jlptLevel,
-        'newspaperFrequencyRank': newspaperFrequencyRank,
-        'strokeCount': strokeCount,
-        'meanings': meanings,
-        'kunyomi': kunyomi,
-        'onyomi': onyomi,
-        // 'onyomiExamples': onyomiExamples,
-        // 'kunyomiExamples': kunyomiExamples,
-        'radical': radical?.toJson(),
-        'parts': parts,
-        'codepoints': codepoints,
-        'nanori': nanori,
-        'alternativeLanguageReadings': alternativeLanguageReadings,
-        'strokeMiscounts': strokeMiscounts,
-        'queryCodes': queryCodes,
-        'dictionaryReferences': dictionaryReferences,
-      };
+    'kanji': kanji,
+    'taughtIn': taughtIn,
+    'jlptLevel': jlptLevel,
+    'newspaperFrequencyRank': newspaperFrequencyRank,
+    'strokeCount': strokeCount,
+    'meanings': meanings,
+    'kunyomi': kunyomi,
+    'onyomi': onyomi,
+    // 'onyomiExamples': onyomiExamples,
+    // 'kunyomiExamples': kunyomiExamples,
+    'radical': radical?.toJson(),
+    'parts': parts,
+    'codepoints': codepoints,
+    'nanori': nanori,
+    'alternativeLanguageReadings': alternativeLanguageReadings,
+    'strokeMiscounts': strokeMiscounts,
+    'queryCodes': queryCodes,
+    'dictionaryReferences': dictionaryReferences,
+  };
 
   factory KanjiSearchResult.fromJson(Map<String, dynamic> json) {
     return KanjiSearchResult(
@@ -156,23 +156,20 @@ class KanjiSearchResult extends Equatable {
       nanori: (json['nanori'] as List).map((e) => e as String).toList(),
       alternativeLanguageReadings:
           (json['alternativeLanguageReadings'] as Map<String, dynamic>).map(
-        (key, value) => MapEntry(
-          key,
-          (value as List).map((e) => e as String).toList(),
-        ),
-      ),
-      strokeMiscounts:
-          (json['strokeMiscounts'] as List).map((e) => e as int).toList(),
+            (key, value) =>
+                MapEntry(key, (value as List).map((e) => e as String).toList()),
+          ),
+      strokeMiscounts: (json['strokeMiscounts'] as List)
+          .map((e) => e as int)
+          .toList(),
       queryCodes: (json['queryCodes'] as Map<String, dynamic>).map(
-        (key, value) => MapEntry(
-          key,
-          (value as List).map((e) => e as String).toList(),
-        ),
+        (key, value) =>
+            MapEntry(key, (value as List).map((e) => e as String).toList()),
       ),
       dictionaryReferences:
           (json['dictionaryReferences'] as Map<String, dynamic>).map(
-        (key, value) => MapEntry(key, value as String),
-      ),
+            (key, value) => MapEntry(key, value as String),
+          ),
     );
   }
 }

lib/models/verify_tables.dart

@@ -7,14 +7,14 @@ import 'package:sqflite_common/sqlite_api.dart';
 Future<void> verifyTablesWithDbConnection(DatabaseExecutor db) async {
   final Set<String> tables = await db
       .query(
-    'sqlite_master',
-    columns: ['name'],
-    where: 'type = ?',
-    whereArgs: ['table'],
-  )
+        'sqlite_master',
+        columns: ['name'],
+        where: 'type = ?',
+        whereArgs: ['table'],
+      )
       .then((result) {
-    return result.map((row) => row['name'] as String).toSet();
-  });
+        return result.map((row) => row['name'] as String).toSet();
+      });
 
   final Set<String> expectedTables = {
     ...JMdictTableNames.allTables,
@@ -26,14 +26,16 @@ Future<void> verifyTablesWithDbConnection(DatabaseExecutor db) async {
   final missingTables = expectedTables.difference(tables);
 
   if (missingTables.isNotEmpty) {
-    throw Exception([
-      'Missing tables:',
-      missingTables.map((table) => '  - $table').join('\n'),
-      '',
-      'Found tables:\n',
-      tables.map((table) => '  - $table').join('\n'),
-      '',
-      'Please ensure the database is correctly set up.',
-    ].join('\n'));
+    throw Exception(
+      [
+        'Missing tables:',
+        missingTables.map((table) => '  - $table').join('\n'),
+        '',
+        'Found tables:\n',
+        tables.map((table) => '  - $table').join('\n'),
+        '',
+        'Please ensure the database is correctly set up.',
+      ].join('\n'),
+    );
   }
 }

lib/models/word_search/word_search_result.dart

@@ -47,18 +47,18 @@ class WordSearchResult {
   });
 
   Map<String, dynamic> toJson() => {
-        '_score': score,
-        'entryId': entryId,
-        'isCommon': isCommon,
-        'japanese': japanese.map((e) => e.toJson()).toList(),
-        'kanjiInfo':
-            kanjiInfo.map((key, value) => MapEntry(key, value.toJson())),
-        'readingInfo':
-            readingInfo.map((key, value) => MapEntry(key, value.toJson())),
-        'senses': senses.map((e) => e.toJson()).toList(),
-        'jlptLevel': jlptLevel.toJson(),
-        'sources': sources.toJson(),
-      };
+    '_score': score,
+    'entryId': entryId,
+    'isCommon': isCommon,
+    'japanese': japanese.map((e) => e.toJson()).toList(),
+    'kanjiInfo': kanjiInfo.map((key, value) => MapEntry(key, value.toJson())),
+    'readingInfo': readingInfo.map(
+      (key, value) => MapEntry(key, value.toJson()),
+    ),
+    'senses': senses.map((e) => e.toJson()).toList(),
+    'jlptLevel': jlptLevel.toJson(),
+    'sources': sources.toJson(),
+  };
 
   factory WordSearchResult.fromJson(Map<String, dynamic> json) =>
       WordSearchResult(

lib/models/word_search/word_search_ruby.dart

@@ -6,18 +6,12 @@ class WordSearchRuby {
   /// Furigana, if applicable.
   String? furigana;
 
-  WordSearchRuby({
-    required this.base,
-    this.furigana,
-  });
+  WordSearchRuby({required this.base, this.furigana});
 
-  Map<String, dynamic> toJson() => {
-        'base': base,
-        'furigana': furigana,
-      };
+  Map<String, dynamic> toJson() => {'base': base, 'furigana': furigana};
 
   factory WordSearchRuby.fromJson(Map<String, dynamic> json) => WordSearchRuby(
-        base: json['base'] as String,
-        furigana: json['furigana'] as String?,
-      );
+    base: json['base'] as String,
+    furigana: json['furigana'] as String?,
+  );
 }

lib/models/word_search/word_search_sense.dart

@@ -71,18 +71,18 @@ class WordSearchSense {
       languageSource.isEmpty;
 
   Map<String, dynamic> toJson() => {
-        'englishDefinitions': englishDefinitions,
-        'partsOfSpeech': partsOfSpeech.map((e) => e.toJson()).toList(),
-        'seeAlso': seeAlso.map((e) => e.toJson()).toList(),
-        'antonyms': antonyms.map((e) => e.toJson()).toList(),
-        'restrictedToReading': restrictedToReading,
-        'restrictedToKanji': restrictedToKanji,
-        'fields': fields.map((e) => e.toJson()).toList(),
-        'dialects': dialects.map((e) => e.toJson()).toList(),
-        'misc': misc.map((e) => e.toJson()).toList(),
-        'info': info,
-        'languageSource': languageSource,
-      };
+    'englishDefinitions': englishDefinitions,
+    'partsOfSpeech': partsOfSpeech.map((e) => e.toJson()).toList(),
+    'seeAlso': seeAlso.map((e) => e.toJson()).toList(),
+    'antonyms': antonyms.map((e) => e.toJson()).toList(),
+    'restrictedToReading': restrictedToReading,
+    'restrictedToKanji': restrictedToKanji,
+    'fields': fields.map((e) => e.toJson()).toList(),
+    'dialects': dialects.map((e) => e.toJson()).toList(),
+    'misc': misc.map((e) => e.toJson()).toList(),
+    'info': info,
+    'languageSource': languageSource,
+  };
 
   factory WordSearchSense.fromJson(Map<String, dynamic> json) =>
       WordSearchSense(
@@ -104,8 +104,9 @@ class WordSearchSense {
         dialects: (json['dialects'] as List)
             .map((e) => JMdictDialect.fromJson(e))
             .toList(),
-        misc:
-            (json['misc'] as List).map((e) => JMdictMisc.fromJson(e)).toList(),
+        misc: (json['misc'] as List)
+            .map((e) => JMdictMisc.fromJson(e))
+            .toList(),
         info: List<String>.from(json['info']),
         languageSource: (json['languageSource'] as List)
             .map((e) => WordSearchSenseLanguageSource.fromJson(e))

lib/models/word_search/word_search_sense_language_source.dart

@@ -13,11 +13,11 @@ class WordSearchSenseLanguageSource {
   });
 
   Map<String, Object?> toJson() => {
-        'language': language,
-        'phrase': phrase,
-        'fullyDescribesSense': fullyDescribesSense,
-        'constructedFromSmallerWords': constructedFromSmallerWords,
-      };
+    'language': language,
+    'phrase': phrase,
+    'fullyDescribesSense': fullyDescribesSense,
+    'constructedFromSmallerWords': constructedFromSmallerWords,
+  };
 
   factory WordSearchSenseLanguageSource.fromJson(Map<String, dynamic> json) =>
       WordSearchSenseLanguageSource(

lib/models/word_search/word_search_sources.dart

@@ -7,20 +7,11 @@ class WordSearchSources {
   /// Whether JMnedict was used.
   final bool jmnedict;
 
-  const WordSearchSources({
-    this.jmdict = true,
-    this.jmnedict = false,
-  });
+  const WordSearchSources({this.jmdict = true, this.jmnedict = false});
 
-  Map<String, Object?> get sqlValue => {
-        'jmdict': jmdict,
-        'jmnedict': jmnedict,
-      };
+  Map<String, Object?> get sqlValue => {'jmdict': jmdict, 'jmnedict': jmnedict};
 
-  Map<String, dynamic> toJson() => {
-        'jmdict': jmdict,
-        'jmnedict': jmnedict,
-      };
+  Map<String, dynamic> toJson() => {'jmdict': jmdict, 'jmnedict': jmnedict};
 
   factory WordSearchSources.fromJson(Map<String, dynamic> json) =>
       WordSearchSources(

lib/models/word_search/word_search_xref_entry.dart

@@ -21,11 +21,11 @@ class WordSearchXrefEntry {
   });
 
   Map<String, dynamic> toJson() => {
-        'entryId': entryId,
-        'ambiguous': ambiguous,
-        'baseWord': baseWord,
-        'furigana': furigana,
-      };
+    'entryId': entryId,
+    'ambiguous': ambiguous,
+    'baseWord': baseWord,
+    'furigana': furigana,
+  };
 
   factory WordSearchXrefEntry.fromJson(Map<String, dynamic> json) =>
       WordSearchXrefEntry(