@genspectrum/dashboard-components 0.6.18 → 0.6.19

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,7 +2,7 @@ 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>();
         map2d.set('a', 'b', 2);
@@ -86,6 +86,34 @@ describe('Map2dContainer', () => {
 
         expect(map2d.getRow('c', 0)).toEqual([]);
     });
+
+    it('should return content as object', () => {
+        const map2d = new Map2dBase<string, string, number>();
+        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>();
+        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', () => {

package/src/utils/map2d.ts

@@ -22,6 +22,12 @@ export interface Map2d<Key1, Key2, Value> {
     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>
 {
@@ -32,7 +38,14 @@ export class Map2dBase<Key1 extends object | string, Key2 extends object | strin
     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)),
-    ) {}
+        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 +97,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

package/src/utils/temporal.spec.ts

@@ -5,23 +5,26 @@ import {
     generateAllMonthsInRange,
     generateAllYearsInRange,
     TemporalCache,
-    Year,
-    YearMonth,
-    YearMonthDay,
-    YearWeek,
-} from './temporal';
+    YearClass,
+    YearMonthClass,
+    YearMonthDayClass,
+    YearWeekClass,
+} from './temporalClass';
 
 const cache = TemporalCache.getInstance();
 
 describe('generateAllDaysInRange', () => {
     it('should return all days in range', () => {
         expect(
-            generateAllDaysInRange(YearMonthDay.parse('2020-01-01', cache), YearMonthDay.parse('2020-01-04', cache)),
+            generateAllDaysInRange(
+                YearMonthDayClass.parse('2020-01-01', cache),
+                YearMonthDayClass.parse('2020-01-04', cache),
+            ),
         ).deep.equal([
-            YearMonthDay.parse('2020-01-01', cache),
-            YearMonthDay.parse('2020-01-02', cache),
-            YearMonthDay.parse('2020-01-03', cache),
-            YearMonthDay.parse('2020-01-04', cache),
+            YearMonthDayClass.parse('2020-01-01', cache),
+            YearMonthDayClass.parse('2020-01-02', cache),
+            YearMonthDayClass.parse('2020-01-03', cache),
+            YearMonthDayClass.parse('2020-01-04', cache),
         ]);
     });
 });
@@ -29,30 +32,30 @@ describe('generateAllDaysInRange', () => {
 describe('generateAllMonthsInRange', () => {
     it('should return all months in range', () => {
         expect(
-            generateAllMonthsInRange(YearMonth.parse('2020-01', cache), YearMonth.parse('2020-04', cache)),
+            generateAllMonthsInRange(YearMonthClass.parse('2020-01', cache), YearMonthClass.parse('2020-04', cache)),
         ).deep.equal([
-            YearMonth.parse('2020-01', cache),
-            YearMonth.parse('2020-02', cache),
-            YearMonth.parse('2020-03', cache),
-            YearMonth.parse('2020-04', cache),
+            YearMonthClass.parse('2020-01', cache),
+            YearMonthClass.parse('2020-02', cache),
+            YearMonthClass.parse('2020-03', cache),
+            YearMonthClass.parse('2020-04', cache),
         ]);
     });
 });
 
 describe('generateAllYearsInRange', () => {
     it('should return all years in range', () => {
-        expect(generateAllYearsInRange(Year.parse('2020-01', cache), Year.parse('2023', cache))).deep.equal([
-            Year.parse('2020', cache),
-            Year.parse('2021', cache),
-            Year.parse('2022', cache),
-            Year.parse('2023', cache),
+        expect(generateAllYearsInRange(YearClass.parse('2020-01', cache), YearClass.parse('2023', cache))).deep.equal([
+            YearClass.parse('2020', cache),
+            YearClass.parse('2021', cache),
+            YearClass.parse('2022', cache),
+            YearClass.parse('2023', cache),
         ]);
     });
 });
 
 describe('YearMonthDay', () => {
     it('should parse from string', () => {
-        const underTest = YearMonthDay.parse('2020-01-01', cache);
+        const underTest = YearMonthDayClass.parse('2020-01-01', cache);
 
         expect(underTest.yearNumber).equal(2020);
         expect(underTest.monthNumber).equal(1);
@@ -66,7 +69,7 @@ describe('YearMonthDay', () => {
 
 describe('YearWeek', () => {
     it('should parse from string', () => {
-        const underTest = YearWeek.parse('2020-W02', cache);
+        const underTest = YearWeekClass.parse('2020-W02', cache);
 
         expect(underTest.isoYearNumber).equal(2020);
         expect(underTest.isoWeekNumber).equal(2);
@@ -78,7 +81,7 @@ describe('YearWeek', () => {
 
 describe('YearMonth', () => {
     it('should parse from string', () => {
-        const underTest = YearMonth.parse('2020-01', cache);
+        const underTest = YearMonthClass.parse('2020-01', cache);
 
         expect(underTest.yearNumber).equal(2020);
         expect(underTest.monthNumber).equal(1);
@@ -90,7 +93,7 @@ describe('YearMonth', () => {
 
 describe('Year', () => {
     it('should parse from string', () => {
-        const underTest = Year.parse('2020', cache);
+        const underTest = YearClass.parse('2020', cache);
 
         expect(underTest.year).equal(2020);
         expect(underTest.text).equal('2020');