updated deps

app/ios/Flutter/Generated.xcconfig

@@ -4,8 +4,8 @@ FLUTTER_APPLICATION_PATH=/home/fafre/Repos/kagi_bang_bang/app
 COCOAPODS_PARALLEL_CODE_SIGN=true
 FLUTTER_TARGET=lib/main.dart
 FLUTTER_BUILD_DIR=build
-FLUTTER_BUILD_NAME=0.6.1
+FLUTTER_BUILD_NAME=0.6.2
-FLUTTER_BUILD_NUMBER=13
+FLUTTER_BUILD_NUMBER=14
 EXCLUDED_ARCHS[sdk=iphonesimulator*]=i386
 EXCLUDED_ARCHS[sdk=iphoneos*]=armv7
 DART_OBFUSCATION=false

app/ios/Flutter/flutter_export_environment.sh

@@ -5,8 +5,8 @@ export "FLUTTER_APPLICATION_PATH=/home/fafre/Repos/kagi_bang_bang/app"
 export "COCOAPODS_PARALLEL_CODE_SIGN=true"
 export "FLUTTER_TARGET=lib/main.dart"
 export "FLUTTER_BUILD_DIR=build"
-export "FLUTTER_BUILD_NAME=0.6.1"
+export "FLUTTER_BUILD_NAME=0.6.2"
-export "FLUTTER_BUILD_NUMBER=13"
+export "FLUTTER_BUILD_NUMBER=14"
 export "DART_OBFUSCATION=false"
 export "TRACK_WIDGET_CREATION=true"
 export "TREE_SHAKE_ICONS=false"

app/lib/features/bangs/data/database/database.g.dart

@@ -1214,66 +1214,39 @@ typedef $BangTableUpdateCompanionBuilder = BangCompanion Function({
   Value<int> rowid,
 });
 
-class $BangTableTableManager extends RootTableManager<
+final class $BangTableReferences
-    _$BangDatabase,
+    extends BaseReferences<_$BangDatabase, BangTable, Bang> {
-    BangTable,
+  $BangTableReferences(super.$_db, super.$_table, super.$_typedResult);
-    Bang,
+
-    $BangTableFilterComposer,
+  static MultiTypedResultKey<BangFrequency, List<BangFrequencyData>>
-    $BangTableOrderingComposer,
+      _bangFrequencyRefsTable(_$BangDatabase db) =>
-    $BangTableCreateCompanionBuilder,
+          MultiTypedResultKey.fromTable(db.bangFrequency,
-    $BangTableUpdateCompanionBuilder> {
+              aliasName: $_aliasNameGenerator(
-  $BangTableTableManager(_$BangDatabase db, BangTable table)
+                  db.bang.trigger, db.bangFrequency.trigger));
-      : super(TableManagerState(
+
-          db: db,
+  $BangFrequencyProcessedTableManager get bangFrequencyRefs {
-          table: table,
+    final manager = $BangFrequencyTableManager($_db, $_db.bangFrequency)
-          filteringComposer: $BangTableFilterComposer(ComposerState(db, table)),
+        .filter((f) => f.trigger.trigger($_item.trigger));
-          orderingComposer:
+
-              $BangTableOrderingComposer(ComposerState(db, table)),
+    final cache = $_typedResult.readTableOrNull(_bangFrequencyRefsTable($_db));
-          updateCompanionCallback: ({
+    return ProcessedTableManager(
-            Value<String> trigger = const Value.absent(),
+        manager.$state.copyWith(prefetchedData: cache));
-            Value<BangGroup> group = const Value.absent(),
+  }
-            Value<String> websiteName = const Value.absent(),
+
-            Value<String> domain = const Value.absent(),
+  static MultiTypedResultKey<BangIcon, List<BangIconData>> _bangIconRefsTable(
-            Value<String> urlTemplate = const Value.absent(),
+          _$BangDatabase db) =>
-            Value<String?> category = const Value.absent(),
+      MultiTypedResultKey.fromTable(db.bangIcon,
-            Value<String?> subCategory = const Value.absent(),
+          aliasName:
-            Value<Set<BangFormat>?> format = const Value.absent(),
+              $_aliasNameGenerator(db.bang.trigger, db.bangIcon.trigger));
-            Value<int> rowid = const Value.absent(),
+
-          }) =>
+  $BangIconProcessedTableManager get bangIconRefs {
-              BangCompanion(
+    final manager = $BangIconTableManager($_db, $_db.bangIcon)
-            trigger: trigger,
+        .filter((f) => f.trigger.trigger($_item.trigger));
-            group: group,
+
-            websiteName: websiteName,
+    final cache = $_typedResult.readTableOrNull(_bangIconRefsTable($_db));
-            domain: domain,
+    return ProcessedTableManager(
-            urlTemplate: urlTemplate,
+        manager.$state.copyWith(prefetchedData: cache));
-            category: category,
+  }
-            subCategory: subCategory,
-            format: format,
-            rowid: rowid,
-          ),
-          createCompanionCallback: ({
-            required String trigger,
-            required BangGroup group,
-            required String websiteName,
-            required String domain,
-            required String urlTemplate,
-            Value<String?> category = const Value.absent(),
-            Value<String?> subCategory = const Value.absent(),
-            Value<Set<BangFormat>?> format = const Value.absent(),
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              BangCompanion.insert(
-            trigger: trigger,
-            group: group,
-            websiteName: websiteName,
-            domain: domain,
-            urlTemplate: urlTemplate,
-            category: category,
-            subCategory: subCategory,
-            format: format,
-            rowid: rowid,
-          ),
-        ));
 }
 
 class $BangTableFilterComposer
@@ -1394,6 +1367,124 @@ class $BangTableOrderingComposer
           ColumnOrderings(column, joinBuilders: joinBuilders));
 }
 
+class $BangTableTableManager extends RootTableManager<
+    _$BangDatabase,
+    BangTable,
+    Bang,
+    $BangTableFilterComposer,
+    $BangTableOrderingComposer,
+    $BangTableCreateCompanionBuilder,
+    $BangTableUpdateCompanionBuilder,
+    (Bang, $BangTableReferences),
+    Bang,
+    PrefetchHooks Function({bool bangFrequencyRefs, bool bangIconRefs})> {
+  $BangTableTableManager(_$BangDatabase db, BangTable table)
+      : super(TableManagerState(
+          db: db,
+          table: table,
+          filteringComposer: $BangTableFilterComposer(ComposerState(db, table)),
+          orderingComposer:
+              $BangTableOrderingComposer(ComposerState(db, table)),
+          updateCompanionCallback: ({
+            Value<String> trigger = const Value.absent(),
+            Value<BangGroup> group = const Value.absent(),
+            Value<String> websiteName = const Value.absent(),
+            Value<String> domain = const Value.absent(),
+            Value<String> urlTemplate = const Value.absent(),
+            Value<String?> category = const Value.absent(),
+            Value<String?> subCategory = const Value.absent(),
+            Value<Set<BangFormat>?> format = const Value.absent(),
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              BangCompanion(
+            trigger: trigger,
+            group: group,
+            websiteName: websiteName,
+            domain: domain,
+            urlTemplate: urlTemplate,
+            category: category,
+            subCategory: subCategory,
+            format: format,
+            rowid: rowid,
+          ),
+          createCompanionCallback: ({
+            required String trigger,
+            required BangGroup group,
+            required String websiteName,
+            required String domain,
+            required String urlTemplate,
+            Value<String?> category = const Value.absent(),
+            Value<String?> subCategory = const Value.absent(),
+            Value<Set<BangFormat>?> format = const Value.absent(),
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              BangCompanion.insert(
+            trigger: trigger,
+            group: group,
+            websiteName: websiteName,
+            domain: domain,
+            urlTemplate: urlTemplate,
+            category: category,
+            subCategory: subCategory,
+            format: format,
+            rowid: rowid,
+          ),
+          withReferenceMapper: (p0) => p0
+              .map((e) =>
+                  (e.readTable(table), $BangTableReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: (
+              {bangFrequencyRefs = false, bangIconRefs = false}) {
+            return PrefetchHooks(
+              db: db,
+              explicitlyWatchedTables: [
+                if (bangFrequencyRefs) db.bangFrequency,
+                if (bangIconRefs) db.bangIcon
+              ],
+              addJoins: null,
+              getPrefetchedDataCallback: (items) async {
+                return [
+                  if (bangFrequencyRefs)
+                    await $_getPrefetchedData(
+                        currentTable: table,
+                        referencedTable:
+                            $BangTableReferences._bangFrequencyRefsTable(db),
+                        managerFromTypedResult: (p0) =>
+                            $BangTableReferences(db, table, p0)
+                                .bangFrequencyRefs,
+                        referencedItemsForCurrentItem:
+                            (item, referencedItems) => referencedItems
+                                .where((e) => e.trigger == item.trigger),
+                        typedResults: items),
+                  if (bangIconRefs)
+                    await $_getPrefetchedData(
+                        currentTable: table,
+                        referencedTable:
+                            $BangTableReferences._bangIconRefsTable(db),
+                        managerFromTypedResult: (p0) =>
+                            $BangTableReferences(db, table, p0).bangIconRefs,
+                        referencedItemsForCurrentItem:
+                            (item, referencedItems) => referencedItems
+                                .where((e) => e.trigger == item.trigger),
+                        typedResults: items)
+                ];
+              },
+            );
+          },
+        ));
+}
+
+typedef $BangTableProcessedTableManager = ProcessedTableManager<
+    _$BangDatabase,
+    BangTable,
+    Bang,
+    $BangTableFilterComposer,
+    $BangTableOrderingComposer,
+    $BangTableCreateCompanionBuilder,
+    $BangTableUpdateCompanionBuilder,
+    (Bang, $BangTableReferences),
+    Bang,
+    PrefetchHooks Function({bool bangFrequencyRefs, bool bangIconRefs})>;
 typedef $BangSyncCreateCompanionBuilder = BangSyncCompanion Function({
   Value<BangGroup> group,
   required DateTime lastSync,
@@ -1403,39 +1494,6 @@ typedef $BangSyncUpdateCompanionBuilder = BangSyncCompanion Function({
   Value<DateTime> lastSync,
 });
 
-class $BangSyncTableManager extends RootTableManager<
-    _$BangDatabase,
-    BangSync,
-    BangSyncData,
-    $BangSyncFilterComposer,
-    $BangSyncOrderingComposer,
-    $BangSyncCreateCompanionBuilder,
-    $BangSyncUpdateCompanionBuilder> {
-  $BangSyncTableManager(_$BangDatabase db, BangSync table)
-      : super(TableManagerState(
-          db: db,
-          table: table,
-          filteringComposer: $BangSyncFilterComposer(ComposerState(db, table)),
-          orderingComposer: $BangSyncOrderingComposer(ComposerState(db, table)),
-          updateCompanionCallback: ({
-            Value<BangGroup> group = const Value.absent(),
-            Value<DateTime> lastSync = const Value.absent(),
-          }) =>
-              BangSyncCompanion(
-            group: group,
-            lastSync: lastSync,
-          ),
-          createCompanionCallback: ({
-            Value<BangGroup> group = const Value.absent(),
-            required DateTime lastSync,
-          }) =>
-              BangSyncCompanion.insert(
-            group: group,
-            lastSync: lastSync,
-          ),
-        ));
-}
-
 class $BangSyncFilterComposer extends FilterComposer<_$BangDatabase, BangSync> {
   $BangSyncFilterComposer(super.$state);
   ColumnWithTypeConverterFilters<BangGroup, BangGroup, int> get group =>
@@ -1465,6 +1523,57 @@ class $BangSyncOrderingComposer
           ColumnOrderings(column, joinBuilders: joinBuilders));
 }
 
+class $BangSyncTableManager extends RootTableManager<
+    _$BangDatabase,
+    BangSync,
+    BangSyncData,
+    $BangSyncFilterComposer,
+    $BangSyncOrderingComposer,
+    $BangSyncCreateCompanionBuilder,
+    $BangSyncUpdateCompanionBuilder,
+    (BangSyncData, BaseReferences<_$BangDatabase, BangSync, BangSyncData>),
+    BangSyncData,
+    PrefetchHooks Function()> {
+  $BangSyncTableManager(_$BangDatabase db, BangSync table)
+      : super(TableManagerState(
+          db: db,
+          table: table,
+          filteringComposer: $BangSyncFilterComposer(ComposerState(db, table)),
+          orderingComposer: $BangSyncOrderingComposer(ComposerState(db, table)),
+          updateCompanionCallback: ({
+            Value<BangGroup> group = const Value.absent(),
+            Value<DateTime> lastSync = const Value.absent(),
+          }) =>
+              BangSyncCompanion(
+            group: group,
+            lastSync: lastSync,
+          ),
+          createCompanionCallback: ({
+            Value<BangGroup> group = const Value.absent(),
+            required DateTime lastSync,
+          }) =>
+              BangSyncCompanion.insert(
+            group: group,
+            lastSync: lastSync,
+          ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
+        ));
+}
+
+typedef $BangSyncProcessedTableManager = ProcessedTableManager<
+    _$BangDatabase,
+    BangSync,
+    BangSyncData,
+    $BangSyncFilterComposer,
+    $BangSyncOrderingComposer,
+    $BangSyncCreateCompanionBuilder,
+    $BangSyncUpdateCompanionBuilder,
+    (BangSyncData, BaseReferences<_$BangDatabase, BangSync, BangSyncData>),
+    BangSyncData,
+    PrefetchHooks Function()>;
 typedef $BangFrequencyCreateCompanionBuilder = BangFrequencyCompanion Function({
   required String trigger,
   required int frequency,
@@ -1478,47 +1587,22 @@ typedef $BangFrequencyUpdateCompanionBuilder = BangFrequencyCompanion Function({
   Value<int> rowid,
 });
 
-class $BangFrequencyTableManager extends RootTableManager<
+final class $BangFrequencyReferences
-    _$BangDatabase,
+    extends BaseReferences<_$BangDatabase, BangFrequency, BangFrequencyData> {
-    BangFrequency,
+  $BangFrequencyReferences(super.$_db, super.$_table, super.$_typedResult);
-    BangFrequencyData,
+
-    $BangFrequencyFilterComposer,
+  static BangTable _triggerTable(_$BangDatabase db) => db.bang.createAlias(
-    $BangFrequencyOrderingComposer,
+      $_aliasNameGenerator(db.bangFrequency.trigger, db.bang.trigger));
-    $BangFrequencyCreateCompanionBuilder,
+
-    $BangFrequencyUpdateCompanionBuilder> {
+  $BangTableProcessedTableManager? get trigger {
-  $BangFrequencyTableManager(_$BangDatabase db, BangFrequency table)
+    if ($_item.trigger == null) return null;
-      : super(TableManagerState(
+    final manager = $BangTableTableManager($_db, $_db.bang)
-          db: db,
+        .filter((f) => f.trigger($_item.trigger!));
-          table: table,
+    final item = $_typedResult.readTableOrNull(_triggerTable($_db));
-          filteringComposer:
+    if (item == null) return manager;
-              $BangFrequencyFilterComposer(ComposerState(db, table)),
+    return ProcessedTableManager(
-          orderingComposer:
+        manager.$state.copyWith(prefetchedData: [item]));
-              $BangFrequencyOrderingComposer(ComposerState(db, table)),
+  }
-          updateCompanionCallback: ({
-            Value<String> trigger = const Value.absent(),
-            Value<int> frequency = const Value.absent(),
-            Value<DateTime> lastUsed = const Value.absent(),
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              BangFrequencyCompanion(
-            trigger: trigger,
-            frequency: frequency,
-            lastUsed: lastUsed,
-            rowid: rowid,
-          ),
-          createCompanionCallback: ({
-            required String trigger,
-            required int frequency,
-            required DateTime lastUsed,
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              BangFrequencyCompanion.insert(
-            trigger: trigger,
-            frequency: frequency,
-            lastUsed: lastUsed,
-            rowid: rowid,
-          ),
-        ));
 }
 
 class $BangFrequencyFilterComposer
@@ -1573,6 +1657,100 @@ class $BangFrequencyOrderingComposer
   }
 }
 
+class $BangFrequencyTableManager extends RootTableManager<
+    _$BangDatabase,
+    BangFrequency,
+    BangFrequencyData,
+    $BangFrequencyFilterComposer,
+    $BangFrequencyOrderingComposer,
+    $BangFrequencyCreateCompanionBuilder,
+    $BangFrequencyUpdateCompanionBuilder,
+    (BangFrequencyData, $BangFrequencyReferences),
+    BangFrequencyData,
+    PrefetchHooks Function({bool trigger})> {
+  $BangFrequencyTableManager(_$BangDatabase db, BangFrequency table)
+      : super(TableManagerState(
+          db: db,
+          table: table,
+          filteringComposer:
+              $BangFrequencyFilterComposer(ComposerState(db, table)),
+          orderingComposer:
+              $BangFrequencyOrderingComposer(ComposerState(db, table)),
+          updateCompanionCallback: ({
+            Value<String> trigger = const Value.absent(),
+            Value<int> frequency = const Value.absent(),
+            Value<DateTime> lastUsed = const Value.absent(),
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              BangFrequencyCompanion(
+            trigger: trigger,
+            frequency: frequency,
+            lastUsed: lastUsed,
+            rowid: rowid,
+          ),
+          createCompanionCallback: ({
+            required String trigger,
+            required int frequency,
+            required DateTime lastUsed,
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              BangFrequencyCompanion.insert(
+            trigger: trigger,
+            frequency: frequency,
+            lastUsed: lastUsed,
+            rowid: rowid,
+          ),
+          withReferenceMapper: (p0) => p0
+              .map((e) =>
+                  (e.readTable(table), $BangFrequencyReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: ({trigger = false}) {
+            return PrefetchHooks(
+              db: db,
+              explicitlyWatchedTables: [],
+              addJoins: <
+                  T extends TableManagerState<
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic>>(state) {
+                if (trigger) {
+                  state = state.withJoin(
+                    currentTable: table,
+                    currentColumn: table.trigger,
+                    referencedTable: $BangFrequencyReferences._triggerTable(db),
+                    referencedColumn:
+                        $BangFrequencyReferences._triggerTable(db).trigger,
+                  ) as T;
+                }
+
+                return state;
+              },
+              getPrefetchedDataCallback: (items) async {
+                return [];
+              },
+            );
+          },
+        ));
+}
+
+typedef $BangFrequencyProcessedTableManager = ProcessedTableManager<
+    _$BangDatabase,
+    BangFrequency,
+    BangFrequencyData,
+    $BangFrequencyFilterComposer,
+    $BangFrequencyOrderingComposer,
+    $BangFrequencyCreateCompanionBuilder,
+    $BangFrequencyUpdateCompanionBuilder,
+    (BangFrequencyData, $BangFrequencyReferences),
+    BangFrequencyData,
+    PrefetchHooks Function({bool trigger})>;
 typedef $BangIconCreateCompanionBuilder = BangIconCompanion Function({
   required String trigger,
   required Uint8List iconData,
@@ -1586,45 +1764,22 @@ typedef $BangIconUpdateCompanionBuilder = BangIconCompanion Function({
   Value<int> rowid,
 });
 
-class $BangIconTableManager extends RootTableManager<
+final class $BangIconReferences
-    _$BangDatabase,
+    extends BaseReferences<_$BangDatabase, BangIcon, BangIconData> {
-    BangIcon,
+  $BangIconReferences(super.$_db, super.$_table, super.$_typedResult);
-    BangIconData,
+
-    $BangIconFilterComposer,
+  static BangTable _triggerTable(_$BangDatabase db) => db.bang
-    $BangIconOrderingComposer,
+      .createAlias($_aliasNameGenerator(db.bangIcon.trigger, db.bang.trigger));
-    $BangIconCreateCompanionBuilder,
+
-    $BangIconUpdateCompanionBuilder> {
+  $BangTableProcessedTableManager? get trigger {
-  $BangIconTableManager(_$BangDatabase db, BangIcon table)
+    if ($_item.trigger == null) return null;
-      : super(TableManagerState(
+    final manager = $BangTableTableManager($_db, $_db.bang)
-          db: db,
+        .filter((f) => f.trigger($_item.trigger!));
-          table: table,
+    final item = $_typedResult.readTableOrNull(_triggerTable($_db));
-          filteringComposer: $BangIconFilterComposer(ComposerState(db, table)),
+    if (item == null) return manager;
-          orderingComposer: $BangIconOrderingComposer(ComposerState(db, table)),
+    return ProcessedTableManager(
-          updateCompanionCallback: ({
+        manager.$state.copyWith(prefetchedData: [item]));
-            Value<String> trigger = const Value.absent(),
+  }
-            Value<Uint8List> iconData = const Value.absent(),
-            Value<DateTime> fetchDate = const Value.absent(),
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              BangIconCompanion(
-            trigger: trigger,
-            iconData: iconData,
-            fetchDate: fetchDate,
-            rowid: rowid,
-          ),
-          createCompanionCallback: ({
-            required String trigger,
-            required Uint8List iconData,
-            required DateTime fetchDate,
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              BangIconCompanion.insert(
-            trigger: trigger,
-            iconData: iconData,
-            fetchDate: fetchDate,
-            rowid: rowid,
-          ),
-        ));
 }
 
 class $BangIconFilterComposer extends FilterComposer<_$BangDatabase, BangIcon> {
@@ -1678,6 +1833,98 @@ class $BangIconOrderingComposer
   }
 }
 
+class $BangIconTableManager extends RootTableManager<
+    _$BangDatabase,
+    BangIcon,
+    BangIconData,
+    $BangIconFilterComposer,
+    $BangIconOrderingComposer,
+    $BangIconCreateCompanionBuilder,
+    $BangIconUpdateCompanionBuilder,
+    (BangIconData, $BangIconReferences),
+    BangIconData,
+    PrefetchHooks Function({bool trigger})> {
+  $BangIconTableManager(_$BangDatabase db, BangIcon table)
+      : super(TableManagerState(
+          db: db,
+          table: table,
+          filteringComposer: $BangIconFilterComposer(ComposerState(db, table)),
+          orderingComposer: $BangIconOrderingComposer(ComposerState(db, table)),
+          updateCompanionCallback: ({
+            Value<String> trigger = const Value.absent(),
+            Value<Uint8List> iconData = const Value.absent(),
+            Value<DateTime> fetchDate = const Value.absent(),
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              BangIconCompanion(
+            trigger: trigger,
+            iconData: iconData,
+            fetchDate: fetchDate,
+            rowid: rowid,
+          ),
+          createCompanionCallback: ({
+            required String trigger,
+            required Uint8List iconData,
+            required DateTime fetchDate,
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              BangIconCompanion.insert(
+            trigger: trigger,
+            iconData: iconData,
+            fetchDate: fetchDate,
+            rowid: rowid,
+          ),
+          withReferenceMapper: (p0) => p0
+              .map((e) =>
+                  (e.readTable(table), $BangIconReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: ({trigger = false}) {
+            return PrefetchHooks(
+              db: db,
+              explicitlyWatchedTables: [],
+              addJoins: <
+                  T extends TableManagerState<
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic>>(state) {
+                if (trigger) {
+                  state = state.withJoin(
+                    currentTable: table,
+                    currentColumn: table.trigger,
+                    referencedTable: $BangIconReferences._triggerTable(db),
+                    referencedColumn:
+                        $BangIconReferences._triggerTable(db).trigger,
+                  ) as T;
+                }
+
+                return state;
+              },
+              getPrefetchedDataCallback: (items) async {
+                return [];
+              },
+            );
+          },
+        ));
+}
+
+typedef $BangIconProcessedTableManager = ProcessedTableManager<
+    _$BangDatabase,
+    BangIcon,
+    BangIconData,
+    $BangIconFilterComposer,
+    $BangIconOrderingComposer,
+    $BangIconCreateCompanionBuilder,
+    $BangIconUpdateCompanionBuilder,
+    (BangIconData, $BangIconReferences),
+    BangIconData,
+    PrefetchHooks Function({bool trigger})>;
 typedef $BangFtsCreateCompanionBuilder = BangFtsCompanion Function({
   required String trigger,
   required String websiteName,
@@ -1689,43 +1936,6 @@ typedef $BangFtsUpdateCompanionBuilder = BangFtsCompanion Function({
   Value<int> rowid,
 });
 
-class $BangFtsTableManager extends RootTableManager<
-    _$BangDatabase,
-    BangFts,
-    BangFt,
-    $BangFtsFilterComposer,
-    $BangFtsOrderingComposer,
-    $BangFtsCreateCompanionBuilder,
-    $BangFtsUpdateCompanionBuilder> {
-  $BangFtsTableManager(_$BangDatabase db, BangFts table)
-      : super(TableManagerState(
-          db: db,
-          table: table,
-          filteringComposer: $BangFtsFilterComposer(ComposerState(db, table)),
-          orderingComposer: $BangFtsOrderingComposer(ComposerState(db, table)),
-          updateCompanionCallback: ({
-            Value<String> trigger = const Value.absent(),
-            Value<String> websiteName = const Value.absent(),
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              BangFtsCompanion(
-            trigger: trigger,
-            websiteName: websiteName,
-            rowid: rowid,
-          ),
-          createCompanionCallback: ({
-            required String trigger,
-            required String websiteName,
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              BangFtsCompanion.insert(
-            trigger: trigger,
-            websiteName: websiteName,
-            rowid: rowid,
-          ),
-        ));
-}
-
 class $BangFtsFilterComposer extends FilterComposer<_$BangDatabase, BangFts> {
   $BangFtsFilterComposer(super.$state);
   ColumnFilters<String> get trigger => $state.composableBuilder(
@@ -1753,6 +1963,62 @@ class $BangFtsOrderingComposer
           ColumnOrderings(column, joinBuilders: joinBuilders));
 }
 
+class $BangFtsTableManager extends RootTableManager<
+    _$BangDatabase,
+    BangFts,
+    BangFt,
+    $BangFtsFilterComposer,
+    $BangFtsOrderingComposer,
+    $BangFtsCreateCompanionBuilder,
+    $BangFtsUpdateCompanionBuilder,
+    (BangFt, BaseReferences<_$BangDatabase, BangFts, BangFt>),
+    BangFt,
+    PrefetchHooks Function()> {
+  $BangFtsTableManager(_$BangDatabase db, BangFts table)
+      : super(TableManagerState(
+          db: db,
+          table: table,
+          filteringComposer: $BangFtsFilterComposer(ComposerState(db, table)),
+          orderingComposer: $BangFtsOrderingComposer(ComposerState(db, table)),
+          updateCompanionCallback: ({
+            Value<String> trigger = const Value.absent(),
+            Value<String> websiteName = const Value.absent(),
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              BangFtsCompanion(
+            trigger: trigger,
+            websiteName: websiteName,
+            rowid: rowid,
+          ),
+          createCompanionCallback: ({
+            required String trigger,
+            required String websiteName,
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              BangFtsCompanion.insert(
+            trigger: trigger,
+            websiteName: websiteName,
+            rowid: rowid,
+          ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
+        ));
+}
+
+typedef $BangFtsProcessedTableManager = ProcessedTableManager<
+    _$BangDatabase,
+    BangFts,
+    BangFt,
+    $BangFtsFilterComposer,
+    $BangFtsOrderingComposer,
+    $BangFtsCreateCompanionBuilder,
+    $BangFtsUpdateCompanionBuilder,
+    (BangFt, BaseReferences<_$BangDatabase, BangFts, BangFt>),
+    BangFt,
+    PrefetchHooks Function()>;
+
 class $BangDatabaseManager {
   final _$BangDatabase _db;
   $BangDatabaseManager(this._db);

app/lib/features/chat_archive/data/database/database.g.dart

@@ -455,47 +455,6 @@ typedef $ChatUpdateCompanionBuilder = ChatCompanion Function({
   Value<int> rowid,
 });
 
-class $ChatTableManager extends RootTableManager<
-    _$ChatSearchDatabase,
-    Chat,
-    ChatData,
-    $ChatFilterComposer,
-    $ChatOrderingComposer,
-    $ChatCreateCompanionBuilder,
-    $ChatUpdateCompanionBuilder> {
-  $ChatTableManager(_$ChatSearchDatabase db, Chat table)
-      : super(TableManagerState(
-          db: db,
-          table: table,
-          filteringComposer: $ChatFilterComposer(ComposerState(db, table)),
-          orderingComposer: $ChatOrderingComposer(ComposerState(db, table)),
-          updateCompanionCallback: ({
-            Value<String> fileName = const Value.absent(),
-            Value<String> title = const Value.absent(),
-            Value<String> content = const Value.absent(),
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              ChatCompanion(
-            fileName: fileName,
-            title: title,
-            content: content,
-            rowid: rowid,
-          ),
-          createCompanionCallback: ({
-            required String fileName,
-            required String title,
-            required String content,
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              ChatCompanion.insert(
-            fileName: fileName,
-            title: title,
-            content: content,
-            rowid: rowid,
-          ),
-        ));
-}
-
 class $ChatFilterComposer extends FilterComposer<_$ChatSearchDatabase, Chat> {
   $ChatFilterComposer(super.$state);
   ColumnFilters<String> get fileName => $state.composableBuilder(
@@ -533,6 +492,65 @@ class $ChatOrderingComposer
           ColumnOrderings(column, joinBuilders: joinBuilders));
 }
 
+class $ChatTableManager extends RootTableManager<
+    _$ChatSearchDatabase,
+    Chat,
+    ChatData,
+    $ChatFilterComposer,
+    $ChatOrderingComposer,
+    $ChatCreateCompanionBuilder,
+    $ChatUpdateCompanionBuilder,
+    (ChatData, BaseReferences<_$ChatSearchDatabase, Chat, ChatData>),
+    ChatData,
+    PrefetchHooks Function()> {
+  $ChatTableManager(_$ChatSearchDatabase db, Chat table)
+      : super(TableManagerState(
+          db: db,
+          table: table,
+          filteringComposer: $ChatFilterComposer(ComposerState(db, table)),
+          orderingComposer: $ChatOrderingComposer(ComposerState(db, table)),
+          updateCompanionCallback: ({
+            Value<String> fileName = const Value.absent(),
+            Value<String> title = const Value.absent(),
+            Value<String> content = const Value.absent(),
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              ChatCompanion(
+            fileName: fileName,
+            title: title,
+            content: content,
+            rowid: rowid,
+          ),
+          createCompanionCallback: ({
+            required String fileName,
+            required String title,
+            required String content,
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              ChatCompanion.insert(
+            fileName: fileName,
+            title: title,
+            content: content,
+            rowid: rowid,
+          ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
+        ));
+}
+
+typedef $ChatProcessedTableManager = ProcessedTableManager<
+    _$ChatSearchDatabase,
+    Chat,
+    ChatData,
+    $ChatFilterComposer,
+    $ChatOrderingComposer,
+    $ChatCreateCompanionBuilder,
+    $ChatUpdateCompanionBuilder,
+    (ChatData, BaseReferences<_$ChatSearchDatabase, Chat, ChatData>),
+    ChatData,
+    PrefetchHooks Function()>;
 typedef $ChatFtsCreateCompanionBuilder = ChatFtsCompanion Function({
   required String title,
   required String content,
@@ -544,43 +562,6 @@ typedef $ChatFtsUpdateCompanionBuilder = ChatFtsCompanion Function({
   Value<int> rowid,
 });
 
-class $ChatFtsTableManager extends RootTableManager<
-    _$ChatSearchDatabase,
-    ChatFts,
-    ChatFt,
-    $ChatFtsFilterComposer,
-    $ChatFtsOrderingComposer,
-    $ChatFtsCreateCompanionBuilder,
-    $ChatFtsUpdateCompanionBuilder> {
-  $ChatFtsTableManager(_$ChatSearchDatabase db, ChatFts table)
-      : super(TableManagerState(
-          db: db,
-          table: table,
-          filteringComposer: $ChatFtsFilterComposer(ComposerState(db, table)),
-          orderingComposer: $ChatFtsOrderingComposer(ComposerState(db, table)),
-          updateCompanionCallback: ({
-            Value<String> title = const Value.absent(),
-            Value<String> content = const Value.absent(),
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              ChatFtsCompanion(
-            title: title,
-            content: content,
-            rowid: rowid,
-          ),
-          createCompanionCallback: ({
-            required String title,
-            required String content,
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              ChatFtsCompanion.insert(
-            title: title,
-            content: content,
-            rowid: rowid,
-          ),
-        ));
-}
-
 class $ChatFtsFilterComposer
     extends FilterComposer<_$ChatSearchDatabase, ChatFts> {
   $ChatFtsFilterComposer(super.$state);
@@ -609,6 +590,62 @@ class $ChatFtsOrderingComposer
           ColumnOrderings(column, joinBuilders: joinBuilders));
 }
 
+class $ChatFtsTableManager extends RootTableManager<
+    _$ChatSearchDatabase,
+    ChatFts,
+    ChatFt,
+    $ChatFtsFilterComposer,
+    $ChatFtsOrderingComposer,
+    $ChatFtsCreateCompanionBuilder,
+    $ChatFtsUpdateCompanionBuilder,
+    (ChatFt, BaseReferences<_$ChatSearchDatabase, ChatFts, ChatFt>),
+    ChatFt,
+    PrefetchHooks Function()> {
+  $ChatFtsTableManager(_$ChatSearchDatabase db, ChatFts table)
+      : super(TableManagerState(
+          db: db,
+          table: table,
+          filteringComposer: $ChatFtsFilterComposer(ComposerState(db, table)),
+          orderingComposer: $ChatFtsOrderingComposer(ComposerState(db, table)),
+          updateCompanionCallback: ({
+            Value<String> title = const Value.absent(),
+            Value<String> content = const Value.absent(),
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              ChatFtsCompanion(
+            title: title,
+            content: content,
+            rowid: rowid,
+          ),
+          createCompanionCallback: ({
+            required String title,
+            required String content,
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              ChatFtsCompanion.insert(
+            title: title,
+            content: content,
+            rowid: rowid,
+          ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
+        ));
+}
+
+typedef $ChatFtsProcessedTableManager = ProcessedTableManager<
+    _$ChatSearchDatabase,
+    ChatFts,
+    ChatFt,
+    $ChatFtsFilterComposer,
+    $ChatFtsOrderingComposer,
+    $ChatFtsCreateCompanionBuilder,
+    $ChatFtsUpdateCompanionBuilder,
+    (ChatFt, BaseReferences<_$ChatSearchDatabase, ChatFts, ChatFt>),
+    ChatFt,
+    PrefetchHooks Function()>;
+
 class $ChatSearchDatabaseManager {
   final _$ChatSearchDatabase _db;
   $ChatSearchDatabaseManager(this._db);

app/lib/features/content_block/data/database/database.g.dart

@@ -362,43 +362,6 @@ typedef $HostUpdateCompanionBuilder = HostCompanion Function({
   Value<int> rowid,
 });
 
-class $HostTableManager extends RootTableManager<
-    _$HostDatabase,
-    Host,
-    HostData,
-    $HostFilterComposer,
-    $HostOrderingComposer,
-    $HostCreateCompanionBuilder,
-    $HostUpdateCompanionBuilder> {
-  $HostTableManager(_$HostDatabase db, Host table)
-      : super(TableManagerState(
-          db: db,
-          table: table,
-          filteringComposer: $HostFilterComposer(ComposerState(db, table)),
-          orderingComposer: $HostOrderingComposer(ComposerState(db, table)),
-          updateCompanionCallback: ({
-            Value<String> hostname = const Value.absent(),
-            Value<HostSource> source = const Value.absent(),
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              HostCompanion(
-            hostname: hostname,
-            source: source,
-            rowid: rowid,
-          ),
-          createCompanionCallback: ({
-            required String hostname,
-            required HostSource source,
-            Value<int> rowid = const Value.absent(),
-          }) =>
-              HostCompanion.insert(
-            hostname: hostname,
-            source: source,
-            rowid: rowid,
-          ),
-        ));
-}
-
 class $HostFilterComposer extends FilterComposer<_$HostDatabase, Host> {
   $HostFilterComposer(super.$state);
   ColumnFilters<String> get hostname => $state.composableBuilder(
@@ -427,6 +390,61 @@ class $HostOrderingComposer extends OrderingComposer<_$HostDatabase, Host> {
           ColumnOrderings(column, joinBuilders: joinBuilders));
 }
 
+class $HostTableManager extends RootTableManager<
+    _$HostDatabase,
+    Host,
+    HostData,
+    $HostFilterComposer,
+    $HostOrderingComposer,
+    $HostCreateCompanionBuilder,
+    $HostUpdateCompanionBuilder,
+    (HostData, BaseReferences<_$HostDatabase, Host, HostData>),
+    HostData,
+    PrefetchHooks Function()> {
+  $HostTableManager(_$HostDatabase db, Host table)
+      : super(TableManagerState(
+          db: db,
+          table: table,
+          filteringComposer: $HostFilterComposer(ComposerState(db, table)),
+          orderingComposer: $HostOrderingComposer(ComposerState(db, table)),
+          updateCompanionCallback: ({
+            Value<String> hostname = const Value.absent(),
+            Value<HostSource> source = const Value.absent(),
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              HostCompanion(
+            hostname: hostname,
+            source: source,
+            rowid: rowid,
+          ),
+          createCompanionCallback: ({
+            required String hostname,
+            required HostSource source,
+            Value<int> rowid = const Value.absent(),
+          }) =>
+              HostCompanion.insert(
+            hostname: hostname,
+            source: source,
+            rowid: rowid,
+          ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
+        ));
+}
+
+typedef $HostProcessedTableManager = ProcessedTableManager<
+    _$HostDatabase,
+    Host,
+    HostData,
+    $HostFilterComposer,
+    $HostOrderingComposer,
+    $HostCreateCompanionBuilder,
+    $HostUpdateCompanionBuilder,
+    (HostData, BaseReferences<_$HostDatabase, Host, HostData>),
+    HostData,
+    PrefetchHooks Function()>;
 typedef $HostSyncCreateCompanionBuilder = HostSyncCompanion Function({
   Value<HostSource> source,
   required DateTime lastSync,
@@ -436,39 +454,6 @@ typedef $HostSyncUpdateCompanionBuilder = HostSyncCompanion Function({
   Value<DateTime> lastSync,
 });
 
-class $HostSyncTableManager extends RootTableManager<
-    _$HostDatabase,
-    HostSync,
-    HostSyncData,
-    $HostSyncFilterComposer,
-    $HostSyncOrderingComposer,
-    $HostSyncCreateCompanionBuilder,
-    $HostSyncUpdateCompanionBuilder> {
-  $HostSyncTableManager(_$HostDatabase db, HostSync table)
-      : super(TableManagerState(
-          db: db,
-          table: table,
-          filteringComposer: $HostSyncFilterComposer(ComposerState(db, table)),
-          orderingComposer: $HostSyncOrderingComposer(ComposerState(db, table)),
-          updateCompanionCallback: ({
-            Value<HostSource> source = const Value.absent(),
-            Value<DateTime> lastSync = const Value.absent(),
-          }) =>
-              HostSyncCompanion(
-            source: source,
-            lastSync: lastSync,
-          ),
-          createCompanionCallback: ({
-            Value<HostSource> source = const Value.absent(),
-            required DateTime lastSync,
-          }) =>
-              HostSyncCompanion.insert(
-            source: source,
-            lastSync: lastSync,
-          ),
-        ));
-}
-
 class $HostSyncFilterComposer extends FilterComposer<_$HostDatabase, HostSync> {
   $HostSyncFilterComposer(super.$state);
   ColumnWithTypeConverterFilters<HostSource, HostSource, int> get source =>
@@ -498,6 +483,58 @@ class $HostSyncOrderingComposer
           ColumnOrderings(column, joinBuilders: joinBuilders));
 }
 
+class $HostSyncTableManager extends RootTableManager<
+    _$HostDatabase,
+    HostSync,
+    HostSyncData,
+    $HostSyncFilterComposer,
+    $HostSyncOrderingComposer,
+    $HostSyncCreateCompanionBuilder,
+    $HostSyncUpdateCompanionBuilder,
+    (HostSyncData, BaseReferences<_$HostDatabase, HostSync, HostSyncData>),
+    HostSyncData,
+    PrefetchHooks Function()> {
+  $HostSyncTableManager(_$HostDatabase db, HostSync table)
+      : super(TableManagerState(
+          db: db,
+          table: table,
+          filteringComposer: $HostSyncFilterComposer(ComposerState(db, table)),
+          orderingComposer: $HostSyncOrderingComposer(ComposerState(db, table)),
+          updateCompanionCallback: ({
+            Value<HostSource> source = const Value.absent(),
+            Value<DateTime> lastSync = const Value.absent(),
+          }) =>
+              HostSyncCompanion(
+            source: source,
+            lastSync: lastSync,
+          ),
+          createCompanionCallback: ({
+            Value<HostSource> source = const Value.absent(),
+            required DateTime lastSync,
+          }) =>
+              HostSyncCompanion.insert(
+            source: source,
+            lastSync: lastSync,
+          ),
+          withReferenceMapper: (p0) => p0
+              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
+              .toList(),
+          prefetchHooksCallback: null,
+        ));
+}
+
+typedef $HostSyncProcessedTableManager = ProcessedTableManager<
+    _$HostDatabase,
+    HostSync,
+    HostSyncData,
+    $HostSyncFilterComposer,
+    $HostSyncOrderingComposer,
+    $HostSyncCreateCompanionBuilder,
+    $HostSyncUpdateCompanionBuilder,
+    (HostSyncData, BaseReferences<_$HostDatabase, HostSync, HostSyncData>),
+    HostSyncData,
+    PrefetchHooks Function()>;
+
 class $HostDatabaseManager {
   final _$HostDatabase _db;
   $HostDatabaseManager(this._db);

app/linux/flutter/ephemeral/.plugin_symlinks/file_picker

@@ -1 +1 @@
-/home/fafre/.pub-cache/hosted/pub.dev/file_picker-8.1.1/
+/home/fafre/.pub-cache/hosted/pub.dev/file_picker-8.1.2/

app/linux/flutter/ephemeral/.plugin_symlinks/share_plus

@@ -1 +1 @@
-/home/fafre/.pub-cache/hosted/pub.dev/share_plus-10.0.1/
+/home/fafre/.pub-cache/hosted/pub.dev/share_plus-10.0.2/

app/macos/Flutter/ephemeral/Flutter-Generated.xcconfig

@@ -3,8 +3,8 @@ FLUTTER_ROOT=/home/fafre/Software/flutter
 FLUTTER_APPLICATION_PATH=/home/fafre/Repos/kagi_bang_bang/app
 COCOAPODS_PARALLEL_CODE_SIGN=true
 FLUTTER_BUILD_DIR=build
-FLUTTER_BUILD_NAME=0.6.1
+FLUTTER_BUILD_NAME=0.6.2
-FLUTTER_BUILD_NUMBER=13
+FLUTTER_BUILD_NUMBER=14
 DART_OBFUSCATION=false
 TRACK_WIDGET_CREATION=true
 TREE_SHAKE_ICONS=false

app/macos/Flutter/ephemeral/flutter_export_environment.sh

@@ -4,8 +4,8 @@ export "FLUTTER_ROOT=/home/fafre/Software/flutter"
 export "FLUTTER_APPLICATION_PATH=/home/fafre/Repos/kagi_bang_bang/app"
 export "COCOAPODS_PARALLEL_CODE_SIGN=true"
 export "FLUTTER_BUILD_DIR=build"
-export "FLUTTER_BUILD_NAME=0.6.1"
+export "FLUTTER_BUILD_NAME=0.6.2"
-export "FLUTTER_BUILD_NUMBER=13"
+export "FLUTTER_BUILD_NUMBER=14"
 export "DART_OBFUSCATION=false"
 export "TRACK_WIDGET_CREATION=true"
 export "TREE_SHAKE_ICONS=false"

app/pubspec.lock

@@ -234,10 +234,10 @@ packages:
     dependency: transitive
     description:
       name: crypto
-      sha256: "1dceb0cf05cb63a7852c11560060e53ec2f182079a16ced6f4395c5b0875baf8"
+      sha256: ec30d999af904f33454ba22ed9a86162b35e52b44ac4807d1d93c288041d7d27
       url: "https://pub.dev"
     source: hosted
-    version: "3.0.4"
+    version: "3.0.5"
   csslib:
     dependency: transitive
     description:
@@ -250,26 +250,26 @@ packages:
     dependency: "direct dev"
     description:
       name: custom_lint
-      sha256: "7c0aec12df22f9082146c354692056677f1e70bc43471644d1fdb36c6fdda799"
+      sha256: "4939d89e580c36215e48a7de8fd92f22c79dcc3eb11fda84f3402b3b45aec663"
       url: "https://pub.dev"
     source: hosted
-    version: "0.6.4"
+    version: "0.6.5"
   custom_lint_builder:
     dependency: transitive
     description:
       name: custom_lint_builder
-      sha256: d7dc41e709dde223806660268678be7993559e523eb3164e2a1425fd6f7615a9
+      sha256: d9e5bb63ed52c1d006f5a1828992ba6de124c27a531e8fba0a31afffa81621b3
       url: "https://pub.dev"
     source: hosted
-    version: "0.6.4"
+    version: "0.6.5"
   custom_lint_core:
     dependency: transitive
     description:
       name: custom_lint_core
-      sha256: a85e8f78f4c52f6c63cdaf8c872eb573db0231dcdf3c3a5906d493c1f8bc20e6
+      sha256: "4ddbbdaa774265de44c97054dcec058a83d9081d071785ece601e348c18c267d"
       url: "https://pub.dev"
     source: hosted
-    version: "0.6.3"
+    version: "0.6.5"
   dart_style:
     dependency: transitive
     description:
@@ -290,18 +290,18 @@ packages:
     dependency: "direct main"
     description:
       name: drift
-      sha256: "8fafcd97c0cbfabbcb8132b4465f1bc5210f73d59f1d598506b5b9e7d8b0d8f9"
+      sha256: "15b51e0ee1970455c0c3f7e560f3ac02ecb9c04711a9657586e470b234659dba"
       url: "https://pub.dev"
     source: hosted
-    version: "2.19.2"
+    version: "2.20.0"
   drift_dev:
     dependency: "direct dev"
     description:
       name: drift_dev
-      sha256: ac7647c6cedca99724ca300cff9181f6dd799428f8ed71f94159ed0528eaec26
+      sha256: b9ec6159a731288e805a44225ccbebad507dd84d52ab71352c52584f13199d2d
       url: "https://pub.dev"
     source: hosted
-    version: "2.19.1"
+    version: "2.20.1"
   dynamic_color:
     dependency: "direct main"
     description:
@@ -370,10 +370,10 @@ packages:
     dependency: "direct main"
     description:
       name: file_picker
-      sha256: "1375f8685ca6f0412effecc2db834757e9d0e3e055468053e563794b0755cdcd"
+      sha256: "167bb619cdddaa10ef2907609feb8a79c16dfa479d3afaf960f8e223f754bf12"
       url: "https://pub.dev"
     source: hosted
-    version: "8.1.1"
+    version: "8.1.2"
   fixnum:
     dependency: transitive
     description:
@@ -387,6 +387,14 @@ packages:
     description: flutter
     source: sdk
     version: "0.0.0"
+  flutter_colorpicker:
+    dependency: "direct main"
+    description:
+      name: flutter_colorpicker
+      sha256: "969de5f6f9e2a570ac660fb7b501551451ea2a1ab9e2097e89475f60e07816ea"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.0"
   flutter_hooks:
     dependency: "direct main"
     description:
@@ -633,10 +641,10 @@ packages:
     dependency: "direct main"
     description:
       name: hooks_riverpod
-      sha256: "45b2030a18bcd6dbd680c2c91bc3b33e3fe7c323e3acb5ecec93a613e2fbaa8a"
+      sha256: "97266a91c994951a06ef0ff3a1c7fb261e52ec7f74e87f0614ea0b7411b859b2"
       url: "https://pub.dev"
     source: hosted
-    version: "2.5.1"
+    version: "2.5.2"
   hotreloader:
     dependency: transitive
     description:
@@ -969,10 +977,10 @@ packages:
     dependency: transitive
     description:
       name: riverpod_analyzer_utils
-      sha256: ee72770090078e6841d51355292335f1bc254907c6694283389dcb8156d99a4d
+      sha256: ac28d7bc678471ec986b42d88e5a0893513382ff7542c7ac9634463b044ac72c
       url: "https://pub.dev"
     source: hosted
-    version: "0.5.3"
+    version: "0.5.4"
   riverpod_annotation:
     dependency: "direct main"
     description:
@@ -985,34 +993,34 @@ packages:
     dependency: "direct dev"
     description:
       name: riverpod_generator
-      sha256: "1ad626afbd8b01d168870b13c0b036f8a5bdb57c14cd426dc5b4595466bd6e2f"
+      sha256: "63311e361ffc578d655dfc31b48dfa4ed3bc76fd06f9be845e9bf97c5c11a429"
       url: "https://pub.dev"
     source: hosted
-    version: "2.4.2"
+    version: "2.4.3"
   riverpod_lint:
     dependency: "direct dev"
     description:
       name: riverpod_lint
-      sha256: b95a8cdc6102397f7d51037131c25ce7e51be900be021af4bf0c2d6f1b8f7aa7
+      sha256: a35a92f2c2a4b7a5d95671c96c5432b42c20f26bb3e985e83d0b186471b61a85
       url: "https://pub.dev"
     source: hosted
-    version: "2.3.12"
+    version: "2.3.13"
   rxdart:
     dependency: "direct main"
     description:
       name: rxdart
-      sha256: "0c7c0cedd93788d996e33041ffecda924cc54389199cde4e6a34b440f50044cb"
+      sha256: "5c3004a4a8dbb94bd4bf5412a4def4acdaa12e12f269737a5751369e12d1a962"
       url: "https://pub.dev"
     source: hosted
-    version: "0.27.7"
+    version: "0.28.0"
   share_plus:
     dependency: "direct main"
     description:
       name: share_plus
-      sha256: "38658034f9f3c29f3b37ab0068db15caea9df2dd70d83e99300991a0d756c2a6"
+      sha256: "468c43f285207c84bcabf5737f33b914ceb8eb38398b91e5e3ad1698d1b72a52"
       url: "https://pub.dev"
     source: hosted
-    version: "10.0.1"
+    version: "10.0.2"
   share_plus_platform_interface:
     dependency: transitive
     description:
@@ -1025,10 +1033,10 @@ packages:
     dependency: "direct main"
     description:
       name: shared_preferences
-      sha256: c272f9cabca5a81adc9b0894381e9c1def363e980f960fa903c604c471b22f68
+      sha256: "746e5369a43170c25816cc472ee016d3a66bc13fcf430c0bc41ad7b4b2922051"
       url: "https://pub.dev"
     source: hosted
-    version: "2.3.1"
+    version: "2.3.2"
   shared_preferences_android:
     dependency: transitive
     description:
@@ -1339,7 +1347,7 @@ packages:
     source: hosted
     version: "3.1.2"
   uuid:
-    dependency: transitive
+    dependency: "direct main"
     description:
       name: uuid
       sha256: "83d37c7ad7aaf9aa8e275490669535c8080377cfa7a7004c24dfac53afffaa90"

app/pubspec.yaml

@@ -10,14 +10,15 @@ dependencies:
   animations: ^2.0.11
   collection: ^1.18.0
   copy_with_extension: ^5.0.4
-  drift: ^2.19.2
+  drift: ^2.20.0
   dynamic_color: ^1.7.0
   exceptions: ^0.6.1
   expandable_page_view: ^1.0.17
   fast_equatable: ^1.1.0
-  file_picker: ^8.1.1
+  file_picker: ^8.1.2
   flutter:
     sdk: flutter
+  flutter_colorpicker: ^1.1.0
   flutter_hooks: ^0.20.5
   flutter_inappwebview: ^6.0.0
   flutter_markdown: ^0.7.3+1
@@ -28,7 +29,7 @@ dependencies:
   go_router: ^14.2.3
   google_fonts: ^6.2.1
   home_widget: ^0.6.0
-  hooks_riverpod: ^2.5.1
+  hooks_riverpod: ^2.5.2
   html: ^0.15.4
   http: ^1.2.2
   json_annotation: ^4.9.0
@@ -40,9 +41,9 @@ dependencies:
   path_provider: ^2.1.4
   riverpod: ^2.5.1
   riverpod_annotation: ^2.3.5
-  rxdart: ^0.27.7
+  rxdart: ^0.28.0
-  share_plus: ^10.0.1
+  share_plus: ^10.0.2
-  shared_preferences: ^2.3.1
+  shared_preferences: ^2.3.2
   skeletonizer: ^1.4.2
   speech_to_text_google_dialog: ^0.0.6
   sqlite3: ^2.4.6
@@ -52,21 +53,22 @@ dependencies:
   universal_io: ^2.2.2
   uri_to_file: ^1.0.0
   url_launcher: ^6.3.0
+  uuid: ^4.4.2
   watcher: ^1.1.0
 
 dev_dependencies:
   build_runner: ^2.4.12
   copy_with_extension_gen: ^5.0.4
-  custom_lint: ^0.6.4
+  custom_lint: ^0.6.5
   dependency_validator: ^4.1.0
-  drift_dev: ^2.19.1
+  drift_dev: ^2.20.1
   fast_equatable_lint: ^0.3.0
   flutter_launcher_icons: ^0.13.1
   go_router_builder: ^2.7.1
   json_serializable: ^6.8.0
   lint: ^2.3.0
-  riverpod_generator: ^2.4.2
+  riverpod_generator: ^2.4.3
-  riverpod_lint: ^2.3.12
+  riverpod_lint: ^2.3.13
 
 flutter:
   uses-material-design: true