replace library

Author: SuaYoo

frontend/package.json

@@ -16,7 +16,6 @@
     "@rollup/plugin-commonjs": "^18.0.0",
     "@shoelace-style/localize": "^3.2.1",
     "@shoelace-style/shoelace": "~2.18.0",
-    "@solancer/two-way-map": "^1.0.4",
     "@tailwindcss/container-queries": "^0.1.1",
     "@tanstack/lit-virtual": "^3.13.12",
     "@tanstack/virtual-core": "^3.13.12",

frontend/src/features/collections/collections-add.ts

@@ -1,7 +1,6 @@
 import { localized, msg } from "@lit/localize";
 import { Task, TaskStatus } from "@lit/task";
 import type { SlInput, SlMenuItem } from "@shoelace-style/shoelace";
-import { TwoWayMap } from "@solancer/two-way-map";
 import Fuse from "fuse.js";
 import { html, nothing } from "lit";
 import { customElement, property, query, state } from "lit/decorators.js";
@@ -23,6 +22,7 @@ import type {
 } from "@/types/api";
 import type { Collection, CollectionSearchValues } from "@/types/collection";
 import type { UnderlyingFunction } from "@/types/utils";
+import { TwoWayMap } from "@/utils/TwoWayMap";
 
 const INITIAL_PAGE_SIZE = 10;
 const MIN_SEARCH_LENGTH = 1;

frontend/src/utils/LinkedList.ts

@@ -0,0 +1,75 @@
+/**
+ * Based on https://github.com/solancer/two-way-map/tree/v1.0.3/src
+ */
+
+export interface ILinkedListNode<T> {
+  value: T;
+  next: ILinkedListNode<T> | null;
+  prev: ILinkedListNode<T> | null;
+}
+
+export class LinkedList<T> {
+  private head: ILinkedListNode<T> | null = null;
+  private tail: ILinkedListNode<T> | null = null;
+
+  add(value: T): void {
+    const newNode: ILinkedListNode<T> = { value, next: null, prev: this.tail };
+
+    if (!this.head) {
+      this.head = newNode;
+    } else if (this.tail) {
+      this.tail.next = newNode;
+    }
+
+    this.tail = newNode;
+  }
+
+  remove(value: T): void {
+    let current = this.head;
+
+    while (current) {
+      if (current.value === value) {
+        if (current.prev) {
+          current.prev.next = current.next;
+        } else {
+          this.head = current.next;
+        }
+
+        if (current.next) {
+          current.next.prev = current.prev;
+        } else {
+          this.tail = current.prev;
+        }
+
+        return;
+      }
+
+      current = current.next;
+    }
+  }
+
+  toArray(): T[] {
+    const array: T[] = [];
+    let current = this.head;
+
+    while (current) {
+      array.push(current.value);
+      current = current.next;
+    }
+
+    return array;
+  }
+
+  getFirst(): T | undefined {
+    return this.head?.value;
+  }
+
+  getLast(): T | undefined {
+    return this.tail?.value;
+  }
+
+  clear(): void {
+    this.head = null;
+    this.tail = null;
+  }
+}

frontend/src/utils/TwoWayMap.ts

@@ -0,0 +1,111 @@
+/**
+ * Based on https://github.com/solancer/two-way-map/tree/v1.0.3/src
+ */
+
+import { LinkedList } from "./LinkedList";
+
+export interface ITwoWayMap<K, V> {
+  set: (key: K, value: V) => void;
+  get: (key: K) => V | undefined;
+  getByValue: (value: V) => K | undefined;
+  delete: (key: K) => boolean;
+  keys: () => K[];
+  values: () => V[];
+  entries: () => [K, V][];
+  pop: (key: K, defaultValue?: V) => V | undefined;
+  popitem: (last?: boolean) => [K, V] | undefined;
+  copy: () => ITwoWayMap<K, V>;
+  clear: () => void;
+}
+
+export class TwoWayMap<K, V> implements ITwoWayMap<K, V> {
+  private readonly keyToValueMap = new Map<K, V>();
+  private readonly valueToKeyMap = new Map<V, K>();
+  private readonly orderList = new LinkedList<K>();
+
+  set(key: K, value: V): void {
+    // Check if the key is already in the map and delete the reverse mapping
+    if (this.keyToValueMap.has(key)) {
+      this.valueToKeyMap.delete(this.keyToValueMap.get(key)!);
+    }
+
+    // Check if the value is already in the map and delete the forward mapping
+    if (this.valueToKeyMap.has(value)) {
+      this.keyToValueMap.delete(this.valueToKeyMap.get(value)!);
+    }
+
+    // Set new key-value and value-key mappings
+    this.keyToValueMap.set(key, value);
+    this.valueToKeyMap.set(value, key);
+
+    // Add the key to the order list
+    this.orderList.add(key);
+  }
+
+  get(key: K): V | undefined {
+    return this.keyToValueMap.get(key);
+  }
+
+  getByValue(value: V): K | undefined {
+    return this.valueToKeyMap.get(value);
+  }
+
+  delete(key: K): boolean {
+    if (!this.keyToValueMap.has(key)) {
+      return false;
+    }
+
+    const value = this.keyToValueMap.get(key)!;
+    this.keyToValueMap.delete(key);
+    this.valueToKeyMap.delete(value);
+    this.orderList.remove(key);
+    return true;
+  }
+
+  keys(): K[] {
+    return this.orderList.toArray();
+  }
+
+  values(): V[] {
+    return this.orderList.toArray().map((key) => this.keyToValueMap.get(key)!);
+  }
+
+  entries(): [K, V][] {
+    return this.orderList
+      .toArray()
+      .map((key) => [key, this.keyToValueMap.get(key)!] as [K, V]);
+  }
+
+  pop(key: K, defaultValue?: V): V | undefined {
+    if (this.keyToValueMap.has(key)) {
+      const value = this.keyToValueMap.get(key);
+      this.delete(key);
+      return value;
+    } else {
+      return defaultValue;
+    }
+  }
+
+  popitem(last = true): [K, V] | undefined {
+    const key = last ? this.orderList.getLast() : this.orderList.getFirst();
+    if (key !== undefined) {
+      const value = this.keyToValueMap.get(key);
+      this.delete(key);
+      return [key, value as V];
+    }
+  }
+
+  copy(): TwoWayMap<K, V> {
+    const newMap = new TwoWayMap<K, V>();
+    this.keyToValueMap.forEach((value, key) => {
+      newMap.set(key, value);
+    });
+    return newMap;
+  }
+
+  clear(): void {
+    this.keyToValueMap.clear();
+    this.valueToKeyMap.clear();
+    this.orderList.clear();
+  }
+}