feat: paginated list view

Author: iOSonntag

lib/animations/helpers.dart

@@ -0,0 +1,58 @@
+part of devspace;
+
+
+class TweenAnimationLoopBuilder<T extends Object?> extends StatefulWidget {
+
+  final Tween<T> tween;
+  final Duration duration;
+  final Curve curve;
+  final bool loopWithReverse;
+  final ValueWidgetBuilder<T> builder;
+
+  const TweenAnimationLoopBuilder({
+    super.key,
+    required this.tween,
+    required this.duration,
+    this.curve = Curves.linear,
+    this.loopWithReverse = true,
+    required this.builder
+  });
+
+  @override
+  State<TweenAnimationLoopBuilder> createState() => _TweeLoopnBuilderState<T>();
+}
+
+class _TweeLoopnBuilderState<T extends Object?> extends State<TweenAnimationLoopBuilder<T>> {
+
+  bool _animatingIn = true;
+  Key _keyAnimationWidget = GlobalKey();
+  final Key _keyChild = GlobalKey();
+
+  @override
+  Widget build(BuildContext context)
+  {
+    return  TweenAnimationBuilder<T>(
+      key: _keyAnimationWidget,
+      tween: _animatingIn || !widget.loopWithReverse ? widget.tween : ReverseTween(widget.tween),
+      duration: widget.duration,
+      curve: widget.curve,
+      builder: (context, value, _)
+      {
+        return KeyedSubtree(
+          key: _keyChild,
+          child: widget.builder(context, value, null),
+        );
+      },
+      onEnd: ()
+      {
+        if (!context.mounted) return;
+
+        setState(() 
+        {
+          _animatingIn = !_animatingIn;
+          _keyAnimationWidget = GlobalKey();
+        });
+      },
+    );
+  }
+}

lib/app_flow_systems/paginated_list_view.dart

@@ -0,0 +1,114 @@
+
+
+
+part of devspace;
+
+
+typedef FetchPageItems<T> = Future<PageFetchResult<T>> Function(int pageSize, String? pageCursor);
+
+class PaginatedListView<T> extends StatefulWidget {
+
+  final EdgeInsetsGeometry? padding;
+  final IndexedWidgetBuilder? separatorBuilder;
+  final int pageSize;
+  final FetchPageItems<T> fetchPageItems;
+  final IndexItemBuilder<T> buildItem;
+
+  const PaginatedListView({
+    super.key,
+    this.pageSize = 20,
+    this.padding,
+    this.separatorBuilder,
+    required this.fetchPageItems,
+    required this.buildItem
+  });
+
+  @override
+  State<PaginatedListView> createState() => _PaginatedListViewState<T>();
+}
+
+const String _pagninatedListStartCursor = 'INIT';
+
+class _PaginatedListViewState<T> extends State<PaginatedListView<T>> {
+
+  final PagingController<String, T> _controller = PagingController(firstPageKey: _pagninatedListStartCursor);
+
+  @override
+  void initState()
+  {
+    _controller.addPageRequestListener(_fetchPage);
+    super.initState();
+  }
+
+  Future<void> _fetchPage(String pageKey) async
+  {
+    try
+    {
+      String? pageCursor = pageKey == _pagninatedListStartCursor ? null : pageKey;
+
+      final fetchResult = await widget.fetchPageItems(widget.pageSize, pageCursor);
+
+      final isLastPage = fetchResult.items.length < widget.pageSize || fetchResult.nextCursor == null;
+
+      if (isLastPage)
+      {
+        _controller.appendLastPage(fetchResult.items);
+      }
+      else
+      {
+        _controller.appendPage(fetchResult.items, fetchResult.nextCursor);
+      }
+    }
+    catch (error)
+    {
+      _controller.error = error;
+    }
+  }
+
+  @override
+  Widget build(BuildContext context)
+  {
+    return PagedListView<String, T>.separated(
+      pagingController: _controller,
+      physics: context.animations.scrollPhysics,
+      padding: widget.padding,
+      separatorBuilder: (context, index) => widget.separatorBuilder?.call(context, index) ?? const SizedBox.shrink(),
+      builderDelegate: PagedChildBuilderDelegate<T>(
+        itemBuilder: widget.buildItem,
+        firstPageErrorIndicatorBuilder: (_) => Center(
+          child: ArchInfoBox.error(
+            variant: kInfoBoxVariant.contentPlaceholder,
+            icon: Symbols.error_rounded,
+            title: LibStrings.lib_general_titleError.tr(),
+            message: LibStrings.lib_general_errorUnknown.tr(),
+            onAction: () => _controller.refresh(),
+          ),
+        ),
+        noItemsFoundIndicatorBuilder: (_) => Center(
+          child: ArchInfoBox.info(
+            variant: kInfoBoxVariant.contentPlaceholder,
+            icon: Symbols.format_list_bulleted_rounded,
+            title: LibStrings.lib_general_titleInfo.tr(),
+            message: LibStrings.lib_general_infoNoItemsFound.tr(),
+            onAction: () => _controller.refresh(),
+          ),
+        ),
+        firstPageProgressIndicatorBuilder: (_) => const Center(child: ArchLoadingIndicator(variant: kLoadingIndicatorVariant.special)),
+        newPageProgressIndicatorBuilder: (_) => const Center(child: ArchLoadingIndicator()),
+        // TODO: add all 3 
+        // newPageErrorIndicatorBuilder: (_) => NewPageErrorIndicator(
+        //   error: _controller.error,
+        //   onTryAgain: () => _controller.retryLastFailedRequest(),
+        // ),
+        // noMoreItemsIndicatorBuilder: (_) => NoMoreItemsIndicator(),
+      ),
+    );
+  }
+
+  @override
+  void dispose()
+  {
+    _controller.dispose();
+    super.dispose();
+  }
+}

lib/app_flow_systems/steps_bar.dart

@@ -44,15 +44,15 @@ class StepsBar extends StatelessWidget {
 
     if (specialFinalNextButton)
     {
-      return LibStrings.lib_general_complete.tr();
+      return LibStrings.lib_general_actionComplete.tr();
     }
 
     return _nextButtonTitle();
   }
 
   String _nextButtonTitle()
   {
-    return customNextButtonTitle ?? LibStrings.lib_general_next.tr();
+    return customNextButtonTitle ?? LibStrings.lib_general_actionNext.tr();
   }
 
   String _backButtonTitle()
@@ -64,10 +64,10 @@ class StepsBar extends StatelessWidget {
           return '';
       }
 
-      return customCancelButtonTitle ?? LibStrings.lib_general_cancel.tr();
+      return customCancelButtonTitle ?? LibStrings.lib_general_actionCancel.tr();
     }
 
-    return customBackButtonTitle ?? LibStrings.lib_general_back.tr();
+    return customBackButtonTitle ?? LibStrings.lib_general_actionBack.tr();
   }
 
   bool _finalNextButtonDiffersInAnyWay()

lib/architect/architect_plans.dart

@@ -4,13 +4,15 @@ part of devspace;
 
 Map<Type, WidgetPlan> _defaultWidgetPlans = <Type, WidgetPlan>{
 
-  ButtonData: WidgetPlan<kButtonVariant, ButtonData>(builder: DefaultButton.builder),
-  InfoBoxData: WidgetPlan<kInfoBoxVariant, InfoBoxData>(builder: DefaultInfoBox.builder),
-  LoadingIndicatorData: WidgetPlan<kLoadingIndicatorVariant, LoadingIndicatorData>(builder: DefaultLoadingIndicator.builder),
-  TextFieldData: WidgetPlan<kTextFieldVariant, TextFieldData>(builder: DefaultTextField.builder),
+  ButtonData: WidgetPlanChildless<kButtonVariant, ButtonData>(builder: DefaultButton.builder),
+  CardData: WidgetPlanChildful<kCardVariant, CardData, Widget>(builder: DefaultCard.builder),
+  InfoBoxData: WidgetPlanChildless<kInfoBoxVariant, InfoBoxData>(builder: DefaultInfoBox.builder),
+  LoadingIndicatorData: WidgetPlanChildless<kLoadingIndicatorVariant, LoadingIndicatorData>(builder: DefaultLoadingIndicator.builder),
+  TextFieldData: WidgetPlanChildless<kTextFieldVariant, TextFieldData>(builder: DefaultTextField.builder),
 
 };
 
+
 Map<Type, ObjectPlan> _defaultObjectPlans = <Type, ObjectPlan>{
 
   InputDecorationData: ObjectPlan<InputDecoration, kNoVariants, InputDecorationData>(builder: DefaultInputDecoration.builder),
@@ -24,11 +26,11 @@ class ArchitectPlans {
     return const ArchitectPlans();
   }
 
-  final Map<Type, WidgetPlan> _widgets;
+  final Map<Type, WidgetPlanChildless> _widgets;
   final Map<Type, ObjectPlan> _objects;
 
   const ArchitectPlans({
-    Map<Type, WidgetPlan>? widgets,
+    Map<Type, WidgetPlanChildless>? widgets,
     Map<Type, ObjectPlan>? objects,
   }) : 
     _widgets = widgets ?? const {},

lib/architect/materials/arch_base.dart

@@ -18,12 +18,57 @@ class ArchBase<V extends Enum, T extends PlanData> extends StatelessWidget {
   @override
   Widget build(BuildContext context)
   {
-    WidgetPlan<V, T> plan = Arch.of(context).planForWidget<T>() as WidgetPlan<V, T>;
+    WidgetPlanChildless<V, T> plan = Arch.of(context).planForWidget<T>() as WidgetPlanChildless<V, T>;
 
     return plan.builder(context, variant, data);
   }
 }
 
+class ArchBaseWithChildren<V extends Enum, T extends PlanData> extends StatelessWidget {
+
+  final V variant;
+  final T data;
+  final List<Widget> children;
+
+  const ArchBaseWithChildren({
+    super.key,
+    required this.data,
+    required this.variant,
+    required this.children,
+  });
+
+  @override
+  Widget build(BuildContext context)
+  {
+    WidgetPlanChildful<V, T, List<Widget>> plan = Arch.of(context).planForWidget<T>() as WidgetPlanChildful<V, T, List<Widget>>;
+
+    return plan.builder(context, variant, data, children);
+  }
+}
+
+class ArchBaseWithChild<V extends Enum, T extends PlanData> extends StatelessWidget {
+
+  final V variant;
+  final T data;
+  final Widget child;
+
+  const ArchBaseWithChild({
+    super.key,
+    required this.data,
+    required this.variant,
+    required this.child,
+  });
+
+  @override
+  Widget build(BuildContext context)
+  {
+    WidgetPlanChildful<V, T, Widget> plan = Arch.of(context).planForWidget<T>() as WidgetPlanChildful<V, T, Widget>;
+
+    return plan.builder(context, variant, data, child);
+  }
+}
+
+
 class ArchObjectBase<R extends Object, V extends Enum, T extends PlanData> {
 
   final V variant;

lib/architect/materials/arch_base_stateless_widget.dart

@@ -5,6 +5,18 @@
 
 part of devspace;
 
+abstract class ArchBaseChildfulStatelessWidget<T extends PlanData, C> extends ArchBaseStatelessWidget<T> {
+
+  final C child;
+
+  ArchBaseChildfulStatelessWidget({
+    super.key,
+    required super.data,
+    required this.child,
+    super.allowCustomVariants,
+  });
+}
+
 abstract class ArchBaseStatelessWidget<T extends PlanData> extends StatelessWidget {
 
   final T data;
@@ -44,14 +56,14 @@ abstract class ArchBaseStatelessWidget<T extends PlanData> extends StatelessWidg
       return;
     }
 
-    debugPrint('The following fields are not supported by the widget:\n');
+    debugPrint('[WARNING]\nArchitect Grumbles - Not constructed as planned!\nThe following fields are not supported by the widget $this:\n|\n');
 
     for (var element in _unsupportedFields)
     {
-      debugPrint('- $element');
+      debugPrint('\t- $element');
     }
 
-    debugPrint('\nIf you want to use these fields, you have to create create your own widget or and make sure it is not marked as unsupported.');
+    debugPrint('\n|\nIf you want to use these fields, you have to create create your own widget and/or and make sure it is not marked as unsupported.');
   }
 
 

lib/architect/materials/arch_base_variant_switch.dart

@@ -27,4 +27,30 @@ abstract class ArchBaseVariantSwitch<V extends Enum, T extends PlanData> extends
 
 
 
+}
+
+abstract class ArchBaseChildfulVariantSwitch<V extends Enum, T extends PlanData, C> extends StatelessWidget {
+
+  final V variant;
+  final T data;
+  final C child;
+
+  const ArchBaseChildfulVariantSwitch({
+    super.key,
+    required this.variant,
+    required this.data,
+    required this.child
+  });
+
+  @override
+  @nonVirtual
+  Widget build(BuildContext context)
+  {
+    return buildStyle(context, variant, child);
+  }
+
+  Widget buildStyle(BuildContext context, V style, C child);
+
+  
+
 }