refactor(search): streamline search logic

- Simplified event handling
- Improved state management

Author: fulleni

lib/headlines-search/bloc/headlines_search_bloc.dart

@@ -1,7 +1,6 @@
 import 'package:bloc/bloc.dart';
 import 'package:equatable/equatable.dart';
 import 'package:ht_headlines_repository/ht_headlines_repository.dart';
-import 'package:stream_transform/stream_transform.dart';
 
 part 'headlines_search_event.dart';
 part 'headlines_search_state.dart';
@@ -10,88 +9,71 @@ class HeadlinesSearchBloc
     extends Bloc<HeadlinesSearchEvent, HeadlinesSearchState> {
   HeadlinesSearchBloc({required HtHeadlinesRepository headlinesRepository})
       : _headlinesRepository = headlinesRepository,
-        super(HeadlinesSearchInitial()) {
-    on<HeadlinesSearchTermChanged>(
-      _onSearchTermChanged,
-      transformer: (events, mapper) => events
-          .debounce(const Duration(milliseconds: 300))
-          .asyncExpand(mapper),
-    );
-    on<HeadlinesSearchRequested>(_onSearchRequested);
-    on<HeadlinesSearchLoadMore>(_onSearchLoadMore);
+        super(HeadlinesSearchLoading()) {
+    on<HeadlinesSearchFetchRequested>(_onSearchFetchRequested);
   }
 
   final HtHeadlinesRepository _headlinesRepository;
-  String _searchTerm = '';
   static const _limit = 10;
 
-  Future<void> _onSearchTermChanged(
-    HeadlinesSearchTermChanged event,
+  Future<void> _onSearchFetchRequested(
+    HeadlinesSearchFetchRequested event,
     Emitter<HeadlinesSearchState> emit,
   ) async {
-    _searchTerm = event.searchTerm;
-    if (_searchTerm.isEmpty) {
-      emit(HeadlinesSearchInitial());
-    }
-  }
-
-  Future<void> _onSearchRequested(
-    HeadlinesSearchRequested event,
-    Emitter<HeadlinesSearchState> emit,
-  ) async {
-    if (_searchTerm.isEmpty) {
+    if (event.searchTerm.isEmpty) {
+      emit(const HeadlinesSearchSuccess(
+          headlines: [], hasMore: false, lastSearchTerm: '',),);
       return;
     }
-    emit(HeadlinesSearchLoading());
-    try {
-      final response = await _headlinesRepository.searchHeadlines(
-        query: _searchTerm,
-        limit: _limit,
-      );
-      emit(
-        HeadlinesSearchLoaded(
-          headlines: response.items,
-          hasReachedMax: !response.hasMore,
-          cursor: response.cursor,
-        ),
-      );
-    } on HeadlinesSearchException catch (e) {
-      emit(HeadlinesSearchError(message: e.message));
-    } catch (e) {
-      emit(HeadlinesSearchError(message: e.toString()));
-    }
-  }
-
-  Future<void> _onSearchLoadMore(
-    HeadlinesSearchLoadMore event,
-    Emitter<HeadlinesSearchState> emit,
-  ) async {
-    if (state is! HeadlinesSearchLoaded) return;
-
-    final currentState = state as HeadlinesSearchLoaded;
 
-    if (currentState.hasReachedMax) return;
+    if (state is HeadlinesSearchSuccess &&
+        event.searchTerm == state.lastSearchTerm) {
+      final currentState = state as HeadlinesSearchSuccess;
+      if (!currentState.hasMore) return;
 
-    try {
-      final response = await _headlinesRepository.searchHeadlines(
-        query: _searchTerm,
-        limit: _limit,
-        startAfterId: currentState.cursor,
-      );
-      emit(
-        response.items.isEmpty
-            ? currentState.copyWith(hasReachedMax: true)
-            : currentState.copyWith(
-                headlines: List.of(currentState.headlines)
-                  ..addAll(response.items),
-                hasReachedMax: !response.hasMore,
-                cursor: response.cursor,
-              ),
-      );
-    } on HeadlinesSearchException catch (e) {
-      emit(HeadlinesSearchError(message: e.message));
-    } catch (e) {
-      emit(HeadlinesSearchError(message: e.toString()));
+      try {
+        final response = await _headlinesRepository.searchHeadlines(
+          query: event.searchTerm,
+          limit: _limit,
+          startAfterId: currentState.cursor,
+        );
+        emit(
+          response.items.isEmpty
+              ? currentState.copyWith(hasMore: false)
+              : currentState.copyWith(
+                  headlines: List.of(currentState.headlines)
+                    ..addAll(response.items),
+                  hasMore: response.hasMore,
+                  cursor: response.cursor,
+                ),
+        );
+      } catch (e) {
+        emit(currentState.copyWith(errorMessage: e.toString()));
+      }
+    } else {
+      try {
+        final response = await _headlinesRepository.searchHeadlines(
+          query: event.searchTerm,
+          limit: _limit,
+        );
+        emit(
+          HeadlinesSearchSuccess(
+            headlines: response.items,
+            hasMore: response.hasMore,
+            cursor: response.cursor,
+            lastSearchTerm: event.searchTerm,
+          ),
+        );
+      } catch (e) {
+        emit(
+          HeadlinesSearchSuccess(
+            headlines: const [],
+            hasMore: false,
+            errorMessage: e.toString(),
+            lastSearchTerm: event.searchTerm,
+          ),
+        );
+      }
     }
   }
 }

lib/headlines-search/bloc/headlines_search_event.dart

@@ -7,15 +7,11 @@ sealed class HeadlinesSearchEvent extends Equatable {
   List<Object> get props => [];
 }
 
-final class HeadlinesSearchTermChanged extends HeadlinesSearchEvent {
-  const HeadlinesSearchTermChanged({required this.searchTerm});
+final class HeadlinesSearchFetchRequested extends HeadlinesSearchEvent {
+  const HeadlinesSearchFetchRequested({required this.searchTerm});
 
   final String searchTerm;
 
   @override
   List<Object> get props => [searchTerm];
 }
-
-final class HeadlinesSearchRequested extends HeadlinesSearchEvent {}
-
-final class HeadlinesSearchLoadMore extends HeadlinesSearchEvent {}

lib/headlines-search/bloc/headlines_search_state.dart

@@ -1,48 +1,49 @@
 part of 'headlines_search_bloc.dart';
 
-sealed class HeadlinesSearchState extends Equatable {
+abstract class HeadlinesSearchState extends Equatable {
   const HeadlinesSearchState();
-
+  abstract final String? lastSearchTerm;
   @override
   List<Object?> get props => [];
 }
 
-final class HeadlinesSearchInitial extends HeadlinesSearchState {}
-
-final class HeadlinesSearchLoading extends HeadlinesSearchState {}
+class HeadlinesSearchLoading extends HeadlinesSearchState {
+  @override
+  final String? lastSearchTerm = null;
+  @override
+  List<Object?> get props => [];
+}
 
-final class HeadlinesSearchLoaded extends HeadlinesSearchState {
-  const HeadlinesSearchLoaded({
+class HeadlinesSearchSuccess extends HeadlinesSearchState {
+  const HeadlinesSearchSuccess({
     required this.headlines,
-    this.hasReachedMax = false,
-    this.cursor,
+    required this.hasMore,
+    required this.lastSearchTerm, this.cursor,
+    this.errorMessage,
   });
 
   final List<Headline> headlines;
-  final bool hasReachedMax;
+  final bool hasMore;
   final String? cursor;
-
-  HeadlinesSearchLoaded copyWith({
-    List<Headline>? headlines,
-    bool? hasReachedMax,
-    String? cursor,
-  }) {
-    return HeadlinesSearchLoaded(
-      headlines: headlines ?? this.headlines,
-      hasReachedMax: hasReachedMax ?? this.hasReachedMax,
-      cursor: cursor ?? this.cursor,
-    );
-  }
-
+  final String? errorMessage;
   @override
-  List<Object?> get props => [headlines, hasReachedMax, cursor];
-}
-
-final class HeadlinesSearchError extends HeadlinesSearchState {
-  const HeadlinesSearchError({required this.message});
-
-  final String message;
+  final String? lastSearchTerm;
+
+  HeadlinesSearchSuccess copyWith(
+      {List<Headline>? headlines,
+      bool? hasMore,
+      String? cursor,
+      String? errorMessage,
+      String? lastSearchTerm,}) {
+    return HeadlinesSearchSuccess(
+        headlines: headlines ?? this.headlines,
+        hasMore: hasMore ?? this.hasMore,
+        cursor: cursor ?? this.cursor,
+        errorMessage: errorMessage ?? this.errorMessage,
+        lastSearchTerm: lastSearchTerm ?? this.lastSearchTerm,);
+  }
 
   @override
-  List<Object> get props => [message];
+  List<Object?> get props =>
+      [headlines, hasMore, cursor, errorMessage, lastSearchTerm];
 }