super_sliver_list

You can replace standard Flutter ListView and SliverList with SuperListView and SuperSliverList to gain improved performance for large lists with variable item extents and more predictable scrollbar behavior.

SuperListView works exactly like ListView.builder, and SuperSliverList works with any CustomScrollView configuration using standard delegates.

// SuperListView usage
SuperListView.builder(
  itemCount: 1000,
  itemBuilder: (context, index) {
    return ListTile(title: Text('Item $index'));
  },
)

// SuperSliverList usage
CustomScrollView(
  slivers: <Widget>[
    SuperSliverList(
      delegate: SliverChildListDelegate(
        <Widget>[
          const Text("Item 1"),
          const Text('Item 2'),
        ],
      ),
    ),
  ],
)

To customize the iOS launch screen, you can either replace the image files directly in the example/ios/Runner/Assets.xcassets/LaunchImage.imageset/ directory or use Xcode for a more visual approach.

Using Xcode:

1. Open the iOS workspace using open ios/Runner.xcworkspace.
2. In the Xcode Project Navigator, select Runner/Assets.xcassets.
3. Drag and drop your desired images into the asset catalog.

SuperListView is a high-performance replacement for Flutter's ListView. It is designed to handle large numbers of children (tens or hundreds of thousands) with variable extents without requiring hardcoded extents or prototype children. It maintains the same API surface as ListView, making it a drop-in replacement.

Key advantages over standard ListView:

• Performance remains stable regardless of the number of children.
• Supports jumping and animating to specific items via ListController.
• Advanced extent estimation and precalculation to prevent scrollbar jumping.

SuperListView(
  children: [ ... ],
  // or
  SuperListView.builder(
    itemBuilder: (context, index) => Text('Item $index'),
    itemCount: 1000,
  ),
);

The ChildObstructionExtent class represents the amount of space from the leading and trailing edges where a sliver obstructs its child (e.g., a pinned header). This is used to calculate the correct offset when revealing a child item so that it isn't hidden behind obstructing slivers.

It supports arithmetic operations (+ and -) to combine or subtract obstruction extents from multiple slivers.

final obstruction = ChildObstructionExtent(
  leading: 50.0,
  trailing: 20.0,
);

The ExtentPrecalculationPolicy allows you to control how and when the SuperSliverList eagerly calculates the actual extents of items.

Precalculating extents is useful for smaller lists where the difference between estimated and actual item sizes might cause noticeable

Because SuperSliverList estimates the size of items outside the viewport, scrollbar behavior might be slightly imprecise if estimates are poor. You can improve accuracy by providing an estimateExtent callback that returns an approximate height/extent for a given index.

SuperSliverList(
    delegate: /*...*/,
    estimateExtent: (index) => 100.0, // Provide your own extent estimation
)

To reduce estimation errors, you can instruct SuperSliverList to asynchronously precalculate the actual extents of items. To do this, subclass ExtentPrecalculationPolicy and implement shouldPrecaculateExtents to define when precalculation should occur (e.g., for lists below a certain size).

class MyPrecalculationPolicy extends ExtentPrecalculationPolicy {
  @override
  bool shouldPrecaculateExtents(ExtentPrecalculationContext context) {
    // Eagerly precalculate for lists with less than 100 items
    return context.numberOfItems < 100;
  }
}

// Usage
SuperSliverList(
    delegate: /*...*/,
    extentPrecalculationPolicy: MyPrecalculationPolicy(),
)

Set delayPopulatingCacheArea to true to optimize performance during rapid scrolling. When enabled, items in the cache area (the area just outside the visible viewport) are only built after the scrolling speed slows down. This prevents the CPU from being overwhelmed by building items that are being skipped over during fast swipes.

SuperListView.builder(
  delayPopulatingCacheArea: true,
  itemBuilder: (context, index) => MyItem(index),
  itemCount: 10000,
);

The getOffsetToRevealExt extension on RenderAbstractViewport is an enhanced version of Flutter's standard getOffsetToReveal. It accounts for childObstructionExtent set on slivers, ensuring that when an item is scrolled into view, it is not obscured by pinned headers or other obstructing slivers.

It also allows the queried sliver to access the current OffsetToRevealContext via OffsetToRevealContext.current().

// Inside a RenderAbstractViewport implementation
RevealedOffset result = viewport.getOffsetToRevealExt(
  targetRenderObject,
  alignment: 0.5,
  esimationOnly: false,
  rect: targetRect,
  axis: Axis.vertical,
);

The SuperSliverList widget is a drop-in replacement for SliverList that handles large amounts of variable-extent items efficiently. It provides three main constructors:

1. .builder: Similar to SliverList.builder. Use this for large, dynamic lists where items are built on demand.
2. .separated: Similar to SliverList.separated. Allows providing a separatorBuilder to inject widgets between items.
3. .list: Similar to SliverList.list. Use this when you have a fixed, pre-defined list of child widgets.