Add paging bloc as alternative to paging package

Author: CodeDoctorDE

app/lib/blocs/sourced_paging.dart

@@ -0,0 +1,89 @@
+import 'dart:async';
+
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:dart_mappable/dart_mappable.dart';
+import 'package:equatable/equatable.dart';
+import 'package:flow/cubits/flow.dart';
+import 'package:flow_api/models/model.dart';
+import 'package:flow_api/services/source.dart';
+
+part 'sourced_paging_event.dart';
+part 'sourced_paging_state.dart';
+
+part 'sourced_paging.mapper.dart';
+
+class SourcedPagingBloc<T>
+    extends Bloc<SourcedPagingEvent, SourcedPagingState<T>> {
+  final FlowCubit cubit;
+  final int pageSize;
+  final Future<List<T>?> Function(
+    String source,
+    SourceService service,
+    int offset,
+    int limit,
+  ) _fetch;
+
+  SourcedPagingBloc(
+      {required this.cubit,
+      required Future<List<T>?> Function(String, SourceService, int, int) fetch,
+      this.pageSize = 50})
+      : _fetch = fetch,
+        super(const SourcedPagingInitial()) {
+    on<SourcedPagingFetched<T>>(_onFetched);
+  }
+
+  Future<void> _onFetched(
+    SourcedPagingFetched<T> event,
+    Emitter<SourcedPagingState<T>> emit,
+  ) async {
+    final state = this.state;
+    if (state.hasReachedMax) return;
+
+    try {
+      final currentPageKey = state.currentPageKey ??
+          SourcedModel(cubit.getCurrentSources().first, 0);
+      final previousItems = state is SourcedPagingSuccess<T> ? state.items : [];
+
+      final fetchedItems = (await _fetch(
+                  currentPageKey.source,
+                  cubit.getService(currentPageKey.source),
+                  currentPageKey.model * pageSize,
+                  pageSize) ??
+              <T>[])
+          .map((e) => SourcedModel(currentPageKey.source, e))
+          .toList();
+
+      final sources = cubit.getCurrentSources();
+      final currentSourceIndex = sources.indexOf(currentPageKey.source);
+      final keepSource = fetchedItems.length >= pageSize;
+      final isLastSource = currentSourceIndex >= sources.length - 1;
+
+      if (isLastSource && !keepSource) {
+        emit(SourcedPagingSuccess(
+          currentPageKey: currentPageKey,
+          items: [...previousItems, ...fetchedItems],
+          hasReachedMax: true,
+        ));
+      } else if (keepSource) {
+        emit(SourcedPagingSuccess(
+          items: [...previousItems, ...fetchedItems],
+          currentPageKey: SourcedModel(
+            currentPageKey.source,
+            currentPageKey.model + 1,
+          ),
+        ));
+      } else {
+        final nextSource = sources[currentSourceIndex + 1];
+        emit(SourcedPagingSuccess(
+          items: [...previousItems, ...fetchedItems],
+          currentPageKey: SourcedModel(nextSource, 0),
+        ));
+      }
+    } catch (e) {
+      emit(SourcedPagingFailure(e));
+    }
+  }
+
+  void refresh() => add(SourcedPagingRefresh());
+  void fetch() => add(SourcedPagingFetched<T>());
+}

app/lib/blocs/sourced_paging.mapper.dart

@@ -0,0 +1,20 @@
+part of 'sourced_paging.dart';
+
+abstract class SourcedPagingEvent extends Equatable {
+  @override
+  List<Object> get props => [];
+}
+
+class SourcedPagingFetched<T> extends SourcedPagingEvent {
+  SourcedPagingFetched();
+
+  @override
+  List<Object> get props => [];
+}
+
+class SourcedPagingRefresh<T> extends SourcedPagingEvent {
+  SourcedPagingRefresh();
+
+  @override
+  List<Object> get props => [];
+}

app/lib/blocs/sourced_paging_event.dart

@@ -0,0 +1,46 @@
+part of 'sourced_paging.dart';
+
+enum SourcedPagingStatus { initial, success, failure }
+
+sealed class SourcedPagingState<T> {
+  const SourcedPagingState();
+
+  SourcedModel<int>? get currentPageKey => null;
+  bool get hasReachedMax => false;
+  List<SourcedModel<T>> get items => const [];
+}
+
+final class SourcedPagingInitial<T> extends SourcedPagingState<T> {
+  const SourcedPagingInitial();
+}
+
+@MappableClass(
+    generateMethods: GenerateMethods.copy |
+        GenerateMethods.stringify |
+        GenerateMethods.equals)
+final class SourcedPagingSuccess<T> extends SourcedPagingState<T>
+    with SourcedPagingSuccessMappable<T> {
+  @override
+  final List<SourcedModel<T>> items;
+  @override
+  final SourcedModel<int> currentPageKey;
+  @override
+  final bool hasReachedMax;
+
+  const SourcedPagingSuccess({
+    this.items = const [],
+    required this.currentPageKey,
+    this.hasReachedMax = false,
+  });
+}
+
+final class SourcedPagingFailure<T> extends SourcedPagingState<T> {
+  final Object error;
+  @override
+  final List<SourcedModel<T>> items;
+
+  const SourcedPagingFailure(this.error, {this.items = const []});
+
+  @override
+  bool get hasReachedMax => true;
+}