@genspectrum/dashboard-components 0.6.11 → 0.6.12

package/src/query/queryMutationsOverTime.ts

@@ -12,7 +12,7 @@ import {
     type SubstitutionOrDeletionEntry,
     type TemporalGranularity,
 } from '../types';
-import { Map2d } from '../utils/Map2d';
+import { Map2dBase, type Map2d } from '../utils/map2d';
 import { type Deletion, type Substitution } from '../utils/mutations';
 import {
     dateRangeCompare,
@@ -154,7 +154,7 @@ function fetchAndPrepareSubstitutionsOrDeletions(filter: LapisFilter, sequenceTy
 }
 
 export function groupByMutation(data: MutationOverTimeData[]) {
-    const dataArray = new Map2d<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>(
+    const dataArray = new Map2dBase<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>(
         (mutation) => mutation.code,
         (date) => date.toString(),
     );
@@ -174,7 +174,7 @@ export function groupByMutation(data: MutationOverTimeData[]) {
 }
 
 function addZeroValuesForDatesWithNoMutationData(
-    dataArray: Map2d<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>,
+    dataArray: Map2dBase<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>,
     data: MutationOverTimeData[],
 ) {
     if (dataArray.getFirstAxisKeys().length !== 0) {

package/src/utils/map2d.spec.ts

@@ -1,23 +1,23 @@
 import { describe, expect, it } from 'vitest';
 
-import { Map2d } from './Map2d';
+import { Map2dBase, Map2dView } from './map2d';
 
-describe('Map2d', () => {
+describe('Map2dContainer', () => {
     it('should add a value and return it', () => {
-        const map2d = new Map2d<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>();
         map2d.set('a', 'b', 2);
         expect(map2d.get('a', 'b')).toBe(2);
     });
 
     it('should update a value', () => {
-        const map2d = new Map2d<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>();
         map2d.set('a', 'b', 2);
         map2d.set('a', 'b', 3);
         expect(map2d.get('a', 'b')).toBe(3);
     });
 
     it('should return the data as an array', () => {
-        const map2d = new Map2d<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>();
         map2d.set('a', 'b', 1);
         map2d.set('a', 'd', 2);
         map2d.set('c', 'b', 3);
@@ -30,7 +30,7 @@ describe('Map2d', () => {
     });
 
     it('should fill empty values with the given value', () => {
-        const map2d = new Map2d<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>();
         map2d.set('a', 'b', 2);
         map2d.set('c', 'd', 4);
         expect(map2d.getAsArray(0)).toEqual([
@@ -40,7 +40,7 @@ describe('Map2d', () => {
     });
 
     it('should return the keys from the first axis', () => {
-        const map2d = new Map2d<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>();
         map2d.set('a', 'b', 2);
         map2d.set('c', 'd', 4);
 
@@ -48,7 +48,7 @@ describe('Map2d', () => {
     });
 
     it('should return the keys from the second axis', () => {
-        const map2d = new Map2d<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>();
         map2d.set('a', 'b', 2);
         map2d.set('c', 'd', 4);
 
@@ -56,7 +56,7 @@ describe('Map2d', () => {
     });
 
     it('should work with objects as keys', () => {
-        const map2d = new Map2d<{ a: string }, { b: string }, number>();
+        const map2d = new Map2dBase<{ a: string }, { b: string }, number>();
         map2d.set({ a: 'a' }, { b: 'b' }, 2);
         map2d.set({ a: 'second' }, { b: 'second' }, 3);
 
@@ -65,30 +65,91 @@ describe('Map2d', () => {
     });
 
     it('should update a value with objects as keys', () => {
-        const map2d = new Map2d<{ a: string }, { b: string }, number>();
+        const map2d = new Map2dBase<{ a: string }, { b: string }, number>();
         map2d.set({ a: 'a' }, { b: 'b' }, 2);
         map2d.set({ a: 'a' }, { b: 'b' }, 3);
         expect(map2d.get({ a: 'a' }, { b: 'b' })).toBe(3);
     });
 
-    it('should create a deep copy of the map', () => {
-        const map2d = new Map2d<string, string, number>();
+    it('should return a row by key', () => {
+        const map2d = new Map2dBase<string, string, number>();
         map2d.set('a', 'b', 2);
-        expect(map2d.get('a', 'b')).toBe(2);
+        map2d.set('c', 'd', 4);
+
+        expect(map2d.getRow('a', 0)).toEqual([2, 0]);
+        expect(map2d.getRow('c', 0)).toEqual([0, 4]);
+    });
+
+    it('should return an empty array when the row does not exist', () => {
+        const map2d = new Map2dBase<string, string, number>();
+        map2d.set('a', 'b', 2);
+
+        expect(map2d.getRow('c', 0)).toEqual([]);
+    });
+});
 
-        const copy = map2d.copy();
-        expect(copy.get('a', 'b')).toBe(2);
+describe('Map2dView', () => {
+    it('should show the same data as the container', () => {
+        const container = createBaseContainer();
 
-        map2d.deleteRow('a');
-        expect(map2d.get('a', 'b')).toBe(undefined);
+        const view = new Map2dView<string, string, number>(container);
+
+        expect(view.get('a', 'b')).toBe(container.get('a', 'b'));
+        expect(view.get('a', 'd')).toBe(container.get('a', 'd'));
+        expect(view.get('c', 'b')).toBe(container.get('c', 'b'));
+        expect(view.get('c', 'd')).toBe(container.get('c', 'd'));
+    });
+
+    it('should remove a row', () => {
+        const container = createBaseContainer();
+
+        const view = new Map2dView<string, string, number>(container);
+
+        view.deleteRow('a');
+
+        expect(view.get('a', 'b')).toBeUndefined();
+        expect(view.get('a', 'd')).toBeUndefined();
+        expect(view.get('c', 'b')).toBe(container.get('c', 'b'));
+        expect(view.get('c', 'd')).toBe(container.get('c', 'd'));
+        expect(view.getFirstAxisKeys().length).toBe(1);
+        expect(view.getFirstAxisKeys()[0]).toBe('c');
+        expect(view.getSecondAxisKeys().length).toBe(2);
+    });
+
+    it('should return the view of the data as an array', () => {
+        const container = createBaseContainer();
+        const view = new Map2dView<string, string, number>(container);
+        view.deleteRow('c');
+
+        expect(view.getAsArray(0)).toEqual([[1, 0]]);
+    });
+
+    it('should throw an error when trying to set a value', () => {
+        const container = createBaseContainer();
+        const view = new Map2dView<string, string, number>(container);
+        expect(() => view.set()).toThrowError();
     });
 
     it('should return a row by key', () => {
-        const map2d = new Map2d<string, string, number>();
-        map2d.set('a', 'b', 2);
-        map2d.set('c', 'd', 4);
+        const container = createBaseContainer();
+        const view = new Map2dView<string, string, number>(container);
 
-        expect(map2d.getRow('a', 0)).toEqual([2, 0]);
-        expect(map2d.getRow('c', 0)).toEqual([0, 4]);
+        expect(view.getRow('a', 0)).toEqual([1, 0]);
     });
+
+    it('should return an empty array when the row does not exist', () => {
+        const container = createBaseContainer();
+        const view = new Map2dView<string, string, number>(container);
+        view.deleteRow('c');
+
+        expect(view.getRow('c', 0)).toEqual([]);
+    });
+
+    function createBaseContainer() {
+        const container = new Map2dBase<string, string, number>();
+        container.set('a', 'b', 1);
+        container.set('c', 'b', 3);
+        container.set('c', 'd', 4);
+        return container;
+    }
 });

package/src/utils/map2d.ts

@@ -0,0 +1,158 @@
+import hash from 'object-hash';
+
+export interface Map2d<Key1, Key2, Value> {
+    get(keyFirstAxis: Key1, keySecondAxis: Key2): Value | undefined;
+
+    set(keyFirstAxis: Key1, keySecondAxis: Key2, value: Value): void;
+
+    getRow(key: Key1, fillEmptyWith: Value): Value[];
+
+    deleteRow(key: Key1): void;
+
+    getFirstAxisKeys(): Key1[];
+
+    getSecondAxisKeys(): Key2[];
+
+    getAsArray(fillEmptyWith: Value): Value[][];
+
+    serializeFirstAxis(key: Key1): string;
+    serializeSecondAxis(key: Key2): string;
+
+    readonly keysFirstAxis: Map<string, Key1>;
+    readonly keysSecondAxis: Map<string, Key2>;
+}
+
+export class Map2dBase<Key1 extends object | string, Key2 extends object | string, Value>
+    implements Map2d<Key1, Key2, Value>
+{
+    readonly data: Map<string, Map<string, Value>> = new Map<string, Map<string, Value>>();
+    readonly keysFirstAxis = new Map<string, Key1>();
+    readonly keysSecondAxis = new Map<string, Key2>();
+
+    constructor(
+        readonly serializeFirstAxis: (key: Key1) => string = (key) => (typeof key === 'string' ? key : hash(key)),
+        readonly serializeSecondAxis: (key: Key2) => string = (key) => (typeof key === 'string' ? key : hash(key)),
+    ) {}
+
+    get(keyFirstAxis: Key1, keySecondAxis: Key2) {
+        const serializedKeyFirstAxis = this.serializeFirstAxis(keyFirstAxis);
+        const serializedKeySecondAxis = this.serializeSecondAxis(keySecondAxis);
+        return this.data.get(serializedKeyFirstAxis)?.get(serializedKeySecondAxis);
+    }
+
+    getRow(key: Key1, fillEmptyWith: Value) {
+        const serializedKeyFirstAxis = this.serializeFirstAxis(key);
+        const row = this.data.get(serializedKeyFirstAxis);
+        if (row === undefined) {
+            return [];
+        }
+        return Array.from(this.keysSecondAxis.keys()).map((key) => row.get(key) ?? fillEmptyWith);
+    }
+
+    set(keyFirstAxis: Key1, keySecondAxis: Key2, value: Value) {
+        const serializedKeyFirstAxis = this.serializeFirstAxis(keyFirstAxis);
+        const serializedKeySecondAxis = this.serializeSecondAxis(keySecondAxis);
+
+        if (!this.data.has(serializedKeyFirstAxis)) {
+            this.data.set(serializedKeyFirstAxis, new Map<string, Value>());
+        }
+
+        this.data.get(serializedKeyFirstAxis)!.set(serializedKeySecondAxis, value);
+
+        this.keysFirstAxis.set(serializedKeyFirstAxis, keyFirstAxis);
+        this.keysSecondAxis.set(serializedKeySecondAxis, keySecondAxis);
+    }
+
+    deleteRow(key: Key1) {
+        const serializedKeyFirstAxis = this.serializeFirstAxis(key);
+        this.data.delete(serializedKeyFirstAxis);
+        this.keysFirstAxis.delete(serializedKeyFirstAxis);
+    }
+
+    getFirstAxisKeys() {
+        return Array.from(this.keysFirstAxis.values());
+    }
+
+    getSecondAxisKeys() {
+        return Array.from(this.keysSecondAxis.values());
+    }
+
+    getAsArray(fillEmptyWith: Value) {
+        return this.getFirstAxisKeys().map((firstAxisKey) => {
+            return this.getSecondAxisKeys().map((secondAxisKey) => {
+                return this.get(firstAxisKey, secondAxisKey) ?? fillEmptyWith;
+            });
+        });
+    }
+}
+
+export class Map2dView<Key1 extends object | string, Key2 extends object | string, Value>
+    implements Map2d<Key1, Key2, Value>
+{
+    readonly keysFirstAxis;
+    readonly keysSecondAxis;
+
+    readonly baseMap: Map2d<Key1, Key2, Value>;
+
+    constructor(map: Map2d<Key1, Key2, Value>) {
+        this.keysFirstAxis = new Map(map.keysFirstAxis);
+        this.keysSecondAxis = new Map(map.keysSecondAxis);
+
+        if (map instanceof Map2dView) {
+            this.baseMap = map.baseMap;
+        }
+        this.baseMap = map;
+    }
+
+    serializeFirstAxis(key: Key1) {
+        return this.baseMap.serializeFirstAxis(key);
+    }
+
+    serializeSecondAxis(key: Key2) {
+        return this.baseMap.serializeSecondAxis(key);
+    }
+
+    deleteRow(key: Key1) {
+        this.keysFirstAxis.delete(this.serializeFirstAxis(key));
+    }
+
+    get(keyFirstAxis: Key1, keySecondAxis: Key2) {
+        const firstAxisKey = this.serializeFirstAxis(keyFirstAxis);
+        const secondAxisKey = this.serializeSecondAxis(keySecondAxis);
+
+        if (!this.keysFirstAxis.has(firstAxisKey) || !this.keysSecondAxis.has(secondAxisKey)) {
+            return undefined;
+        }
+
+        return this.baseMap.get(keyFirstAxis, keySecondAxis);
+    }
+
+    set() {
+        throw new Error('Cannot set value on a Map2dView');
+    }
+
+    getFirstAxisKeys() {
+        return Array.from(this.keysFirstAxis.values());
+    }
+
+    getSecondAxisKeys() {
+        return Array.from(this.keysSecondAxis.values());
+    }
+
+    getAsArray(fillEmptyWith: Value) {
+        return this.getFirstAxisKeys().map((firstAxisKey) => {
+            return this.getSecondAxisKeys().map((secondAxisKey) => {
+                return this.baseMap.get(firstAxisKey, secondAxisKey) ?? fillEmptyWith;
+            });
+        });
+    }
+
+    getRow(key: Key1, fillEmptyWith: Value) {
+        const serializedKeyFirstAxis = this.serializeFirstAxis(key);
+        if (!this.keysFirstAxis.has(serializedKeyFirstAxis)) {
+            return [];
+        }
+
+        return this.baseMap.getRow(key, fillEmptyWith);
+    }
+}

package/src/utils/Map2d.ts

@@ -1,75 +0,0 @@
-import hash from 'object-hash';
-
-export class Map2d<Key1 extends object | string, Key2 extends object | string, Value> {
-    readonly data: Map<string, Map<string, Value>> = new Map<string, Map<string, Value>>();
-    readonly keysFirstAxis = new Map<string, Key1>();
-    readonly keysSecondAxis = new Map<string, Key2>();
-
-    constructor(
-        readonly serializeFirstAxis: (key: Key1) => string = (key) => (typeof key === 'string' ? key : hash(key)),
-        readonly serializeSecondAxis: (key: Key2) => string = (key) => (typeof key === 'string' ? key : hash(key)),
-    ) {}
-
-    get(keyFirstAxis: Key1, keySecondAxis: Key2) {
-        const serializedKeyFirstAxis = this.serializeFirstAxis(keyFirstAxis);
-        const serializedKeySecondAxis = this.serializeSecondAxis(keySecondAxis);
-        return this.data.get(serializedKeyFirstAxis)?.get(serializedKeySecondAxis);
-    }
-
-    getRow(key: Key1, fillEmptyWith: Value) {
-        const serializedKeyFirstAxis = this.serializeFirstAxis(key);
-        const row = this.data.get(serializedKeyFirstAxis);
-        if (row === undefined) {
-            return [];
-        }
-        return Array.from(this.keysSecondAxis.keys()).map((key) => row.get(key) ?? fillEmptyWith);
-    }
-
-    set(keyFirstAxis: Key1, keySecondAxis: Key2, value: Value) {
-        const serializedKeyFirstAxis = this.serializeFirstAxis(keyFirstAxis);
-        const serializedKeySecondAxis = this.serializeSecondAxis(keySecondAxis);
-
-        if (!this.data.has(serializedKeyFirstAxis)) {
-            this.data.set(serializedKeyFirstAxis, new Map<string, Value>());
-        }
-
-        this.data.get(serializedKeyFirstAxis)!.set(serializedKeySecondAxis, value);
-
-        this.keysFirstAxis.set(serializedKeyFirstAxis, keyFirstAxis);
-        this.keysSecondAxis.set(serializedKeySecondAxis, keySecondAxis);
-    }
-
-    deleteRow(key: Key1) {
-        const serializedKeyFirstAxis = this.serializeFirstAxis(key);
-        this.data.delete(serializedKeyFirstAxis);
-        this.keysFirstAxis.delete(serializedKeyFirstAxis);
-    }
-
-    getFirstAxisKeys() {
-        return Array.from(this.keysFirstAxis.values());
-    }
-
-    getSecondAxisKeys() {
-        return Array.from(this.keysSecondAxis.values());
-    }
-
-    getAsArray(fillEmptyWith: Value) {
-        return this.getFirstAxisKeys().map((firstAxisKey) => {
-            return this.getSecondAxisKeys().map((secondAxisKey) => {
-                return this.get(firstAxisKey, secondAxisKey) ?? fillEmptyWith;
-            });
-        });
-    }
-
-    copy() {
-        const copy = new Map2d<Key1, Key2, Value>(this.serializeFirstAxis, this.serializeSecondAxis);
-        this.data.forEach((value, key) => {
-            const keyFirstAxis = this.keysFirstAxis.get(key);
-            value.forEach((value, key) => {
-                const keySecondAxis = this.keysSecondAxis.get(key);
-                copy.set(keyFirstAxis!, keySecondAxis!, value);
-            });
-        });
-        return copy;
-    }
-}