model: Implement StreamColorSwatch.lerp, copying ColorSwatch.lerp

It's convenient in this method to access the colors as they're
stored in a Map, like the superclass ColorSwatch does. So, in our
own private field, we save the same Map that we pass along to the
superclass constructor. As Greg says at
  zulip#642 (comment) :

> The redundancy is mildly annoying, but it's only duplicating one
> pointer, so it's not a material cost at runtime.

Author: chrisbobbe

lib/api/model/model.dart

@@ -463,7 +463,17 @@ class Subscription extends ZulipStream {
 /// Use this in UI code for colors related to [Subscription.color],
 /// such as the background of an unread count badge.
 class StreamColorSwatch extends ColorSwatch<StreamColorVariant> {
-  StreamColorSwatch(int base) : super(base, _compute(base));
+  StreamColorSwatch(int base) : this._(base, _compute(base));
+
+  const StreamColorSwatch._(int base, this._swatch) : super(base, _swatch);
+
+  /// A [StreamColorSwatch], from a [Map<_StreamColorVariant, Color>]
+  /// written manually.
+  @visibleForTesting
+  const StreamColorSwatch.debugFromBaseAndSwatch(int base, swatch)
+    : this._(base, swatch);
+
+  final Map<StreamColorVariant, Color> _swatch;
 
   /// The [Subscription.color] int that the swatch is based on.
   Color get base => this[StreamColorVariant.base]!;
@@ -536,6 +546,24 @@ class StreamColorSwatch extends ColorSwatch<StreamColorVariant> {
           .toColor(),
     };
   }
+
+  /// Copied from [ColorSwatch.lerp].
+  static StreamColorSwatch? lerp(StreamColorSwatch? a, StreamColorSwatch? b, double t) {
+    if (identical(a, b)) {
+      return a;
+    }
+    final Map<StreamColorVariant, Color> swatch;
+    if (b == null) {
+      swatch = a!._swatch.map((key, color) => MapEntry(key, Color.lerp(color, null, t)!));
+    } else {
+      if (a == null) {
+        swatch = b._swatch.map((key, color) => MapEntry(key, Color.lerp(null, color, t)!));
+      } else {
+        swatch = a._swatch.map((key, color) => MapEntry(key, Color.lerp(color, b[key], t)!));
+      }
+    }
+    return StreamColorSwatch._(Color.lerp(a, b, t)!.value, swatch);
+  }
 }
 
 @visibleForTesting

test/api/model/model_test.dart

@@ -316,6 +316,48 @@ void main() {
         runCheck(0xffa47462, const Color(0xffe7dad6));
         runCheck(0xffacc25d, const Color(0xffe9edd6));
       });
+
+      test('lerp (different a, b)', () {
+        final swatchA = StreamColorSwatch(0xff76ce90);
+
+        // TODO(#95) use something like StreamColorSwatch.dark(), once
+        //   implemented, and remove debugFromBaseAndSwatch
+        const swatchB = StreamColorSwatch.debugFromBaseAndSwatch(0xff76ce90, <StreamColorVariant, Color>{
+          StreamColorVariant.base:                       Color(0xff76ce90),
+          StreamColorVariant.unreadCountBadgeBackground: Color(0x4d65bd80),
+          StreamColorVariant.iconOnPlainBackground:      Color(0xff73cb8d),
+          StreamColorVariant.iconOnBarBackground:        Color(0xff73cb8d),
+          StreamColorVariant.barBackground:              Color(0xff2e4935),
+        });
+
+        for (final t in [0.0, 0.5, 1.0, -0.1, 1.1]) {
+          final result = StreamColorSwatch.lerp(swatchA, swatchB, t)!;
+          for (final variant in StreamColorVariant.values) {
+            final (subject, expected) = switch (variant) {
+              StreamColorVariant.base => (check(result).base,
+                Color.lerp(swatchA.base, swatchB.base, t)!),
+              StreamColorVariant.unreadCountBadgeBackground => (check(result).unreadCountBadgeBackground,
+                Color.lerp(swatchA.unreadCountBadgeBackground, swatchB.unreadCountBadgeBackground, t)!),
+              StreamColorVariant.iconOnPlainBackground => (check(result).iconOnPlainBackground,
+                Color.lerp(swatchA.iconOnPlainBackground, swatchB.iconOnPlainBackground, t)!),
+              StreamColorVariant.iconOnBarBackground => (check(result).iconOnBarBackground,
+                Color.lerp(swatchA.iconOnBarBackground, swatchB.iconOnBarBackground, t)!),
+              StreamColorVariant.barBackground => (check(result).barBackground,
+                Color.lerp(swatchA.barBackground, swatchB.barBackground, t)!),
+            };
+            subject.equals(expected);
+          }
+        }
+      });
+
+      test('lerp (identical a, b)', () {
+        check(StreamColorSwatch.lerp(null, null, 0.0)).isNull();
+
+        final swatch = StreamColorSwatch(0xff76ce90);
+        check(StreamColorSwatch.lerp(swatch, swatch, 0.5)).isNotNull()
+          ..identicalTo(swatch)
+          ..base.equals(const Color(0xff76ce90));
+      });
     });
   });