performance improvements

apps/weblibre/lib/domain/entities/equatable_image.dart

@@ -19,26 +19,42 @@
  */
 import 'dart:ui';
 
-/// A wrapper around [Image] that compares by a precomputed byte-hash.
+/// What makes one decoded image the *same* image as another.
 ///
-/// Instances are byte-hash deduped via the decoder's LRU, so the same
-/// `EquatableImage` may be shared across many holders (multiple tabs of
-/// the same site, the icon cache, widget closures). To make that safe,
-/// the underlying `ui.Image` is disposed via a [Finalizer] when this
-/// wrapper becomes unreachable — never on cache eviction or state
-/// transitions, where another holder might still be using it.
+/// Deliberately a record rather than a single combined `int`: [digest] is a
+/// 64-bit content hash, and folding it together with the decode options via
+/// `Object.hash` would truncate the whole thing to 30 bits (Dart caps hash
+/// codes at `0x3fffffff`) and leave the result standing in as the identity
+/// with no exact comparison behind it. As a record, hash codes only pick the
+/// bucket and structural `==` decides equality, so the full digest and the
+/// exact options both count.
+typedef ImageIdentity = ({
+  int digest,
+  int? targetWidth,
+  int? targetHeight,
+  bool allowUpscaling,
+});
+
+/// A wrapper around [Image] that compares by a precomputed [ImageIdentity].
+///
+/// Instances are deduped via the decoder's LRU, so the same `EquatableImage`
+/// may be shared across many holders (multiple tabs of the same site, the icon
+/// cache, widget closures). To make that safe, the underlying `ui.Image` is
+/// disposed via a [Finalizer] when this wrapper becomes unreachable — never on
+/// cache eviction or state transitions, where another holder might still be
+/// using it.
 class EquatableImage {
   static final Finalizer<Image> _finalizer = Finalizer<Image>(
     (image) => image.dispose(),
   );
 
   Image? _value;
-  final int _imageHash;
+  final ImageIdentity _identity;
   bool _isDisposed = false;
 
-  EquatableImage(Image value, {required int hash})
+  EquatableImage(Image value, {required ImageIdentity identity})
     : _value = value,
-      _imageHash = hash {
+      _identity = identity {
     _finalizer.attach(this, value, detach: this);
   }
 
@@ -63,10 +79,10 @@ class EquatableImage {
   }
 
   @override
-  int get hashCode => _imageHash.hashCode;
+  int get hashCode => _identity.hashCode;
 
   @override
   bool operator ==(Object other) {
-    return other is EquatableImage && other._imageHash == _imageHash;
+    return other is EquatableImage && other._identity == _identity;
   }
 }