transform method

Reactive<List<T>> transform({ bool filter(T element)?, Comparable sortBy(T element)?, bool? sortByDesc, bool? reverse, bool? shuffle, int? take, })

Transforms the current reactive list into a new reactive list by applying optional filtering, sorting, and list operations.

This method listens to changes on the source reactive list and keeps the returned reactive list in sync after applying the given transformations.

Parameters:

• filter: A predicate used to filter elements. If null, all elements are kept.
• sortBy: A function that returns a comparable value used to sort elements. If null, no sorting is applied.
• sortByDesc: Whether sorting should be in descending order. Only used when sortBy is provided. Defaults to false.
• reverse: Whether to reverse the resulting list.
• shuffle: Whether to shuffle the resulting list randomly.
• take: Limits the number of elements in the resulting list.

Returns: A new Reactive<List<T>> that reflects the transformed version of the source list and updates automatically when the source list changes.

Example:

final users = Reactive<List<User>>([...]);

final topActiveUsers = users.transform(
  filter: (u) => u.isActive,
  sortBy: (u) => u.score,
  sortByDesc: true,
  take: 10,
);

In this example, the returned reactive list will always contain the top 10 active users sorted by score in descending order.

Implementation

Reactive<List<T>> transform({
  bool Function(T element)? filter,
  Comparable<dynamic> Function(T element)? sortBy,
  bool? sortByDesc,
  bool? reverse,
  bool? shuffle,
  int? take,
}) {
  testTrue(_) => true;

  final r = Reactive(value.where(filter ?? testTrue).toList(), strict);

  listen((l) {
    var filtered = l.where(filter ?? testTrue).toList();
    if (sortBy != null) {
      filtered.sort((a, b) {
        if (sortByDesc == true) return sortBy(b).compareTo(sortBy(a));
        return sortBy(a).compareTo(sortBy(b));
      });
    }
    if (reverse == true) {
      filtered = filtered.reversed.toList();
    }
    if (shuffle == true) {
      filtered.shuffle();
    }
    if (take != null) {
      filtered = filtered.take(take).toList();
    }

    r.value = filtered;
  });

  return r;
}