EntityDelta<T>.diff constructor

EntityDelta<T>.diff(
  1. List<T> oldL,
  2. List<T> newL, {
  3. required Object keySelector(
    1. T
    ),
  4. required bool hasSpatialChange(
    1. T oldItem,
    2. T newItem
    ),
})

Computes the difference between two lists.

Implementation

factory EntityDelta.diff(
  List<T> oldL,
  List<T> newL, {
  required Object Function(T) keySelector,
  required bool Function(T oldItem, T newItem) hasSpatialChange,
}) {
  final oldByKey = {for (final item in oldL) keySelector(item): item};
  final newByKey = {for (final item in newL) keySelector(item): item};

  final added = <T>[];
  final removed = <T>[];
  final moved = <(T, T)>[];
  final updated = <(T, T)>[];

  // Find removed
  for (final key in oldByKey.keys) {
    if (!newByKey.containsKey(key)) {
      removed.add(oldByKey[key] as T);
    }
  }

  // Find added, moved, updated
  for (final key in newByKey.keys) {
    final newItem = newByKey[key] as T;
    final oldItem = oldByKey[key];

    if (oldItem == null) {
      added.add(newItem);
      continue;
    }

    if (hasSpatialChange(oldItem, newItem)) {
      moved.add((oldItem, newItem));
      continue;
    }

    if (newItem != oldItem) {
      updated.add((oldItem, newItem));
    }
  }

  return EntityDelta(
    added: added,
    removed: removed,
    moved: moved,
    updated: updated,
  );
}