prepare for multiple apps

apps/weblibre/lib/utils/lru_cache.dart

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2024-2026 Fabian Freund.
+ *
+ * This file is part of WebLibre
+ * (see https://weblibre.eu).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+import 'dart:collection';
+
+class LRUCache<K, V> {
+  int _capacity;
+  final LinkedHashMap<K, V> _cache;
+  final void Function(V)? _onEvict;
+
+  LRUCache(
+    this._capacity, {
+    bool Function(K, K)? equals,
+    int Function(K)? hashCode,
+    bool Function(dynamic)? isValidKey,
+    void Function(V)? onEvict,
+  }) : _onEvict = onEvict,
+       _cache = LinkedHashMap<K, V>(
+         equals: equals,
+         hashCode: hashCode,
+         isValidKey: isValidKey,
+       );
+
+  void resize(int capacity) {
+    if (_capacity > capacity) {
+      _cache.keys.take(_capacity - capacity).forEach((key) {
+        final evicted = _cache.remove(key);
+        if (evicted != null) {
+          _onEvict?.call(evicted);
+        }
+      });
+    }
+
+    _capacity = capacity;
+  }
+
+  bool contains(K key) {
+    return _cache.containsKey(key);
+  }
+
+  V? get(K key) {
+    final value = _cache.remove(key); // Temporarily remove the item.
+
+    if (value != null) {
+      _cache[key] =
+          value; // Re-inserting the item makes it the most-recently used.
+    }
+
+    return value;
+  }
+
+  V set(K key, V value) {
+    V? evicted;
+
+    if (_cache.containsKey(key)) {
+      evicted = _cache.remove(key); // Remove the existing item before updating.
+    } else if (_cache.length == _capacity) {
+      evicted = _cache.remove(
+        _cache.keys.first,
+      ); // Explicitly remove the least recently used item if at capacity.
+    }
+
+    if (evicted != null) {
+      _onEvict?.call(evicted);
+    }
+
+    return _cache[key] = value; // Inserting or updating the item.
+  }
+
+  /// Clears all entries from the cache, calling onEvict for each entry.
+  void clear() {
+    if (_onEvict != null) {
+      for (final value in _cache.values) {
+        _onEvict(value);
+      }
+    }
+    _cache.clear();
+  }
+
+  /// Removes an entry by key, calling onEvict if it existed.
+  V? remove(K key) {
+    final value = _cache.remove(key);
+    if (value != null) {
+      _onEvict?.call(value);
+    }
+    return value;
+  }
+}