@genspectrum/dashboard-components 0.6.18 → 0.7.0

package/src/query/queryRelativeGrowthAdvantage.ts

@@ -2,7 +2,7 @@ import { FetchAggregatedOperator } from '../operator/FetchAggregatedOperator';
 import { MapOperator } from '../operator/MapOperator';
 import { RenameFieldOperator } from '../operator/RenameFieldOperator';
 import { type LapisFilter } from '../types';
-import { getMinMaxTemporal, TemporalCache, type YearMonthDay } from '../utils/temporal';
+import { getMinMaxTemporal, TemporalCache, type YearMonthDayClass } from '../utils/temporalClass';
 
 export type RelativeGrowthAdvantageData = Awaited<ReturnType<typeof queryRelativeGrowthAdvantage>>;
 
@@ -33,13 +33,13 @@ export async function queryRelativeGrowthAdvantage<LapisDateField extends string
         return null;
     }
 
-    const numeratorCounts = new Map<YearMonthDay, number>();
+    const numeratorCounts = new Map<YearMonthDayClass, number>();
     numeratorData.content.forEach((d) => {
         if (d.date) {
             numeratorCounts.set(d.date, d.count);
         }
     });
-    const denominatorCounts = new Map<YearMonthDay, number>();
+    const denominatorCounts = new Map<YearMonthDayClass, number>();
     const requestData = {
         t: [] as number[],
         n: [] as number[],

package/src/types.ts

@@ -1,4 +1,11 @@
-import { type Deletion, type Insertion, type Substitution } from './utils/mutations';
+import {
+    type Deletion,
+    type DeletionClass,
+    type Insertion,
+    type InsertionClass,
+    type Substitution,
+    type SubstitutionClass,
+} from './utils/mutations';
 
 export type LapisFilter = Record<string, string | number | null | boolean>;
 
@@ -15,12 +22,25 @@ export type SubstitutionOrDeletion = 'substitution' | 'deletion';
 
 export type MutationType = SubstitutionOrDeletion | 'insertion';
 
-export type SubstitutionEntry = { type: 'substitution'; mutation: Substitution; count: number; proportion: number };
+export type SubstitutionEntry<T extends Substitution = SubstitutionClass> = {
+    type: 'substitution';
+    mutation: T;
+    count: number;
+    proportion: number;
+};
 
-export type DeletionEntry = { type: 'deletion'; mutation: Deletion; count: number; proportion: number };
+export type DeletionEntry<T extends Deletion = DeletionClass> = {
+    type: 'deletion';
+    mutation: T;
+    count: number;
+    proportion: number;
+};
 
-export type InsertionEntry = { type: 'insertion'; mutation: Insertion; count: number };
+export type InsertionEntry<T extends Insertion = InsertionClass> = { type: 'insertion'; mutation: T; count: number };
 
-export type SubstitutionOrDeletionEntry = SubstitutionEntry | DeletionEntry;
+export type SubstitutionOrDeletionEntry<
+    S extends Substitution = SubstitutionClass,
+    D extends Deletion = DeletionClass,
+> = SubstitutionEntry<S> | DeletionEntry<D>;
 
 export type MutationEntry = SubstitutionEntry | DeletionEntry | InsertionEntry;

package/src/utils/map2d.spec.ts

@@ -2,22 +2,31 @@ import { describe, expect, it } from 'vitest';
 
 import { Map2dBase, Map2dView } from './map2d';
 
-describe('Map2dContainer', () => {
+describe('Map2dBase', () => {
     it('should add a value and return it', () => {
-        const map2d = new Map2dBase<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
         map2d.set('a', 'b', 2);
         expect(map2d.get('a', 'b')).toBe(2);
     });
 
     it('should update a value', () => {
-        const map2d = new Map2dBase<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
         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 Map2dBase<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
         map2d.set('a', 'b', 1);
         map2d.set('a', 'd', 2);
         map2d.set('c', 'b', 3);
@@ -30,7 +39,10 @@ describe('Map2dContainer', () => {
     });
 
     it('should fill empty values with the given value', () => {
-        const map2d = new Map2dBase<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
         map2d.set('a', 'b', 2);
         map2d.set('c', 'd', 4);
         expect(map2d.getAsArray(0)).toEqual([
@@ -40,7 +52,10 @@ describe('Map2dContainer', () => {
     });
 
     it('should return the keys from the first axis', () => {
-        const map2d = new Map2dBase<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
         map2d.set('a', 'b', 2);
         map2d.set('c', 'd', 4);
 
@@ -48,7 +63,10 @@ describe('Map2dContainer', () => {
     });
 
     it('should return the keys from the second axis', () => {
-        const map2d = new Map2dBase<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
         map2d.set('a', 'b', 2);
         map2d.set('c', 'd', 4);
 
@@ -56,7 +74,10 @@ describe('Map2dContainer', () => {
     });
 
     it('should work with objects as keys', () => {
-        const map2d = new Map2dBase<{ a: string }, { b: string }, number>();
+        const map2d = new Map2dBase<{ a: string }, { b: string }, number>(
+            ({ a }) => a,
+            ({ b }) => b,
+        );
         map2d.set({ a: 'a' }, { b: 'b' }, 2);
         map2d.set({ a: 'second' }, { b: 'second' }, 3);
 
@@ -65,14 +86,20 @@ describe('Map2dContainer', () => {
     });
 
     it('should update a value with objects as keys', () => {
-        const map2d = new Map2dBase<{ a: string }, { b: string }, number>();
+        const map2d = new Map2dBase<{ a: string }, { b: string }, number>(
+            ({ a }) => a,
+            ({ b }) => b,
+        );
         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 return a row by key', () => {
-        const map2d = new Map2dBase<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
         map2d.set('a', 'b', 2);
         map2d.set('c', 'd', 4);
 
@@ -81,11 +108,48 @@ describe('Map2dContainer', () => {
     });
 
     it('should return an empty array when the row does not exist', () => {
-        const map2d = new Map2dBase<string, string, number>();
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
         map2d.set('a', 'b', 2);
 
         expect(map2d.getRow('c', 0)).toEqual([]);
     });
+
+    it('should return content as object', () => {
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
+        map2d.set('a', 'b', 2);
+        map2d.set('c', 'd', 4);
+
+        const content = map2d.getContents();
+        expect(Array.from(content.keysFirstAxis.values())).to.deep.equal(['a', 'c']);
+        expect(Array.from(content.keysSecondAxis.values())).to.deep.equal(['b', 'd']);
+        expect(content.data.get('a')?.get('b')).toBe(2);
+    });
+
+    it('should use initial data', () => {
+        const map2d = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
+        map2d.set('a', 'b', 2);
+        map2d.set('c', 'd', 4);
+
+        const content = map2d.getContents();
+
+        const mapWithInitialData = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+            content,
+        );
+
+        expect(mapWithInitialData.get('a', 'b')).toBe(2);
+        expect(mapWithInitialData.get('c', 'd')).toBe(4);
+    });
 });
 
 describe('Map2dView', () => {
@@ -146,7 +210,10 @@ describe('Map2dView', () => {
     });
 
     function createBaseContainer() {
-        const container = new Map2dBase<string, string, number>();
+        const container = new Map2dBase<string, string, number>(
+            (value) => value,
+            (value) => value,
+        );
         container.set('a', 'b', 1);
         container.set('c', 'b', 3);
         container.set('c', 'd', 4);

package/src/utils/map2d.ts

@@ -1,5 +1,3 @@
-import hash from 'object-hash';
-
 export interface Map2d<Key1, Key2, Value> {
     get(keyFirstAxis: Key1, keySecondAxis: Key2): Value | undefined;
 
@@ -16,12 +14,19 @@ export interface Map2d<Key1, Key2, Value> {
     getAsArray(fillEmptyWith: Value): Value[][];
 
     serializeFirstAxis(key: Key1): string;
+
     serializeSecondAxis(key: Key2): string;
 
     readonly keysFirstAxis: Map<string, Key1>;
     readonly keysSecondAxis: Map<string, Key2>;
 }
 
+export type Map2DContents<Key1, Key2, Value> = {
+    keysFirstAxis: Map<string, Key1>;
+    keysSecondAxis: Map<string, Key2>;
+    data: Map<string, Map<string, Value>>;
+};
+
 export class Map2dBase<Key1 extends object | string, Key2 extends object | string, Value>
     implements Map2d<Key1, Key2, Value>
 {
@@ -30,9 +35,16 @@ export class Map2dBase<Key1 extends object | string, Key2 extends object | strin
     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)),
-    ) {}
+        readonly serializeFirstAxis: (key: Key1) => string,
+        readonly serializeSecondAxis: (key: Key2) => string,
+        initialContent?: Map2DContents<Key1, Key2, Value>,
+    ) {
+        if (initialContent) {
+            this.keysFirstAxis = new Map(initialContent.keysFirstAxis);
+            this.keysSecondAxis = new Map(initialContent.keysSecondAxis);
+            this.data = new Map(initialContent.data);
+        }
+    }
 
     get(keyFirstAxis: Key1, keySecondAxis: Key2) {
         const serializedKeyFirstAxis = this.serializeFirstAxis(keyFirstAxis);
@@ -84,6 +96,14 @@ export class Map2dBase<Key1 extends object | string, Key2 extends object | strin
             });
         });
     }
+
+    getContents(): Map2DContents<Key1, Key2, Value> {
+        return {
+            keysFirstAxis: this.keysFirstAxis,
+            keysSecondAxis: this.keysSecondAxis,
+            data: this.data,
+        };
+    }
 }
 
 export class Map2dView<Key1 extends object | string, Key2 extends object | string, Value>

package/src/utils/mutations.spec.ts

@@ -1,21 +1,21 @@
 import { describe, expect, it } from 'vitest';
 
-import { Deletion, Insertion, Substitution } from './mutations';
+import { DeletionClass, InsertionClass, SubstitutionClass } from './mutations';
 
-describe('Substitution', () => {
+describe('SubstitutionClass', () => {
     it('should be parsed from string', () => {
-        expect(Substitution.parse('A1T')).deep.equal(new Substitution(undefined, 'A', 'T', 1));
-        expect(Substitution.parse('seg1:A1T')).deep.equal(new Substitution('seg1', 'A', 'T', 1));
+        expect(SubstitutionClass.parse('A1T')).deep.equal(new SubstitutionClass(undefined, 'A', 'T', 1));
+        expect(SubstitutionClass.parse('seg1:A1T')).deep.equal(new SubstitutionClass('seg1', 'A', 'T', 1));
     });
 
     it('should render to string correctly', () => {
         const substitutions = [
             {
-                substitution: new Substitution(undefined, 'A', 'T', 1),
+                substitution: new SubstitutionClass(undefined, 'A', 'T', 1),
                 expected: 'A1T',
             },
-            { substitution: new Substitution('segment', 'A', 'T', 1), expected: 'segment:A1T' },
-            { substitution: new Substitution(undefined, undefined, undefined, 1), expected: '1' },
+            { substitution: new SubstitutionClass('segment', 'A', 'T', 1), expected: 'segment:A1T' },
+            { substitution: new SubstitutionClass(undefined, undefined, undefined, 1), expected: '1' },
         ];
 
         for (const { substitution, expected } of substitutions) {
@@ -24,20 +24,20 @@ describe('Substitution', () => {
     });
 });
 
-describe('Deletion', () => {
+describe('DeletionClass', () => {
     it('should be parsed from string', () => {
-        expect(Deletion.parse('A1-')).deep.equal(new Deletion(undefined, 'A', 1));
-        expect(Deletion.parse('seg1:A1-')).deep.equal(new Deletion('seg1', 'A', 1));
+        expect(DeletionClass.parse('A1-')).deep.equal(new DeletionClass(undefined, 'A', 1));
+        expect(DeletionClass.parse('seg1:A1-')).deep.equal(new DeletionClass('seg1', 'A', 1));
     });
 
     it('should render to string correctly', () => {
         const substitutions = [
             {
-                deletion: new Deletion(undefined, 'A', 1),
+                deletion: new DeletionClass(undefined, 'A', 1),
                 expected: 'A1-',
             },
-            { deletion: new Deletion('segment', 'A', 1), expected: 'segment:A1-' },
-            { deletion: new Deletion(undefined, undefined, 1), expected: '1-' },
+            { deletion: new DeletionClass('segment', 'A', 1), expected: 'segment:A1-' },
+            { deletion: new DeletionClass(undefined, undefined, 1), expected: '1-' },
         ];
 
         for (const { deletion, expected } of substitutions) {
@@ -46,19 +46,19 @@ describe('Deletion', () => {
     });
 });
 
-describe('Insertion', () => {
+describe('InsertionClass', () => {
     it('should be parsed from string', () => {
-        expect(Insertion.parse('ins_1:A')).deep.equal(new Insertion(undefined, 1, 'A'));
-        expect(Insertion.parse('ins_seg1:1:A')).deep.equal(new Insertion('seg1', 1, 'A'));
+        expect(InsertionClass.parse('ins_1:A')).deep.equal(new InsertionClass(undefined, 1, 'A'));
+        expect(InsertionClass.parse('ins_seg1:1:A')).deep.equal(new InsertionClass('seg1', 1, 'A'));
     });
 
     it('should be parsed with case insensitive ins prefix', () => {
-        expect(Insertion.parse('INS_1:A')).deep.equal(new Insertion(undefined, 1, 'A'));
-        expect(Insertion.parse('iNs_1:A')).deep.equal(new Insertion(undefined, 1, 'A'));
+        expect(InsertionClass.parse('INS_1:A')).deep.equal(new InsertionClass(undefined, 1, 'A'));
+        expect(InsertionClass.parse('iNs_1:A')).deep.equal(new InsertionClass(undefined, 1, 'A'));
     });
 
     it('should be parsed with the other parts not case insensitive', () => {
-        expect(Insertion.parse('ins_geNe1:1:A')).deep.equal(new Insertion('geNe1', 1, 'A'));
-        expect(Insertion.parse('ins_1:aA')).deep.equal(new Insertion(undefined, 1, 'aA'));
+        expect(InsertionClass.parse('ins_geNe1:1:A')).deep.equal(new InsertionClass('geNe1', 1, 'A'));
+        expect(InsertionClass.parse('ins_1:aA')).deep.equal(new InsertionClass(undefined, 1, 'aA'));
     });
 });

package/src/utils/mutations.ts

@@ -1,12 +1,14 @@
 import { type MutationType, type SequenceType } from '../types';
 
 export interface Mutation {
-    readonly segment: string | undefined;
     readonly position: number;
     readonly code: string;
     readonly type: MutationType;
+    readonly segment?: string;
+}
 
-    equals(other: Mutation): boolean;
+export interface MutationClass extends Mutation {
+    equals(other: MutationClass): boolean;
 
     toString(): string;
 }
@@ -14,7 +16,13 @@ export interface Mutation {
 export const substitutionRegex =
     /^((?<segment>[A-Za-z0-9_-]+)(?=:):)?(?<valueAtReference>[A-Za-z])?(?<position>\d+)(?<substitutionValue>[A-Za-z.])?$/;
 
-export class Substitution implements Mutation {
+export interface Substitution extends Mutation {
+    type: 'substitution';
+    valueAtReference: string | undefined;
+    substitutionValue: string | undefined;
+}
+
+export class SubstitutionClass implements MutationClass, Substitution {
     readonly code;
     readonly type = 'substitution';
 
@@ -30,8 +38,8 @@ export class Substitution implements Mutation {
         this.code = `${segmentString}${valueAtReferenceString}${this.position}${substitutionValueString}`;
     }
 
-    equals(other: Mutation): boolean {
-        if (!(other instanceof Substitution)) {
+    equals(other: MutationClass): boolean {
+        if (!(other instanceof SubstitutionClass)) {
             return false;
         }
         return (
@@ -46,12 +54,12 @@ export class Substitution implements Mutation {
         return this.code;
     }
 
-    static parse(mutationStr: string): Substitution | null {
+    static parse(mutationStr: string): SubstitutionClass | null {
         const match = mutationStr.match(substitutionRegex);
         if (match === null || match.groups === undefined) {
             return null;
         }
-        return new Substitution(
+        return new SubstitutionClass(
             match.groups.segment,
             match.groups.valueAtReference,
             match.groups.substitutionValue,
@@ -62,7 +70,12 @@ export class Substitution implements Mutation {
 
 export const deletionRegex = /^((?<segment>[A-Za-z0-9_-]+)(?=:):)?(?<valueAtReference>[A-Za-z])?(?<position>\d+)(-)$/;
 
-export class Deletion implements Mutation {
+export interface Deletion extends Mutation {
+    type: 'deletion';
+    valueAtReference: string | undefined;
+}
+
+export class DeletionClass implements MutationClass, Deletion {
     readonly code;
     readonly type = 'deletion';
 
@@ -76,8 +89,8 @@ export class Deletion implements Mutation {
         this.code = `${segmentString}${valueAtReferenceString}${this.position}-`;
     }
 
-    equals(other: Mutation): boolean {
-        if (!(other instanceof Deletion)) {
+    equals(other: MutationClass): boolean {
+        if (!(other instanceof DeletionClass)) {
             return false;
         }
         return (
@@ -91,20 +104,29 @@ export class Deletion implements Mutation {
         return this.code;
     }
 
-    static parse(mutationStr: string): Deletion | null {
+    static parse(mutationStr: string): DeletionClass | null {
         const match = mutationStr.match(deletionRegex);
         if (match === null || match.groups === undefined) {
             return null;
         }
 
-        return new Deletion(match.groups.segment, match.groups.valueAtReference, parseInt(match.groups.position, 10));
+        return new DeletionClass(
+            match.groups.segment,
+            match.groups.valueAtReference,
+            parseInt(match.groups.position, 10),
+        );
     }
 }
 
 export const insertionRegexp =
     /^ins_((?<segment>[A-Za-z0-9_-]+)(?=:):)?(?<position>\d+):(?<insertedSymbols>(([A-Za-z?]|(\.\*))+))$/i;
 
-export class Insertion implements Mutation {
+export interface Insertion extends Mutation {
+    type: 'insertion';
+    insertedSymbols: string;
+}
+
+export class InsertionClass implements MutationClass {
     readonly code;
     readonly type = 'insertion';
 
@@ -116,8 +138,8 @@ export class Insertion implements Mutation {
         this.code = `ins_${this.segment ? `${this.segment}:` : ''}${this.position}:${this.insertedSymbols}`;
     }
 
-    equals(other: Mutation): boolean {
-        if (!(other instanceof Insertion)) {
+    equals(other: MutationClass): boolean {
+        if (!(other instanceof InsertionClass)) {
             return false;
         }
         return (
@@ -131,13 +153,54 @@ export class Insertion implements Mutation {
         return this.code;
     }
 
-    static parse(mutationStr: string): Insertion | null {
+    static parse(mutationStr: string): InsertionClass | null {
         const match = mutationStr.match(insertionRegexp);
         if (match === null || match.groups === undefined) {
             return null;
         }
 
-        return new Insertion(match.groups.segment, parseInt(match.groups.position, 10), match.groups.insertedSymbols);
+        return new InsertionClass(
+            match.groups.segment,
+            parseInt(match.groups.position, 10),
+            match.groups.insertedSymbols,
+        );
+    }
+}
+
+export function toMutation(
+    mutationClass: SubstitutionClass | DeletionClass | InsertionClass,
+): Substitution | Deletion | Insertion {
+    if (mutationClass.type === 'insertion') {
+        return {
+            type: 'insertion' as const,
+            code: mutationClass.code,
+            segment: mutationClass.segment,
+            position: mutationClass.position,
+            insertedSymbols: mutationClass.insertedSymbols,
+        };
+    }
+    return toSubstitutionOrDeletion(mutationClass);
+}
+
+export function toSubstitutionOrDeletion(mutation: SubstitutionClass | DeletionClass): Substitution | Deletion {
+    switch (mutation.type) {
+        case 'substitution':
+            return {
+                type: 'substitution' as const,
+                code: mutation.code,
+                segment: mutation.segment,
+                position: mutation.position,
+                valueAtReference: mutation.valueAtReference,
+                substitutionValue: mutation.substitutionValue,
+            };
+        case 'deletion':
+            return {
+                type: 'deletion' as const,
+                code: mutation.code,
+                segment: mutation.segment,
+                position: mutation.position,
+                valueAtReference: mutation.valueAtReference,
+            };
     }
 }
 

package/src/utils/sort.ts

@@ -1,6 +1,9 @@
-import type { Temporal } from './temporal';
+import type { TemporalClass } from './temporalClass';
 
-export function sortNullToBeginningThenByDate(a: { dateRange: Temporal | null }, b: { dateRange: Temporal | null }) {
+export function sortNullToBeginningThenByDate(
+    a: { dateRange: TemporalClass | null },
+    b: { dateRange: TemporalClass | null },
+) {
     return a.dateRange === null
         ? -1
         : b.dateRange === null