@genspectrum/dashboard-components 0.6.18 → 0.7.0

package/src/preact/mutationFilter/parseMutation.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 
 import { parseAndValidateMutation } from './parseAndValidateMutation';
-import { Deletion, Insertion, Substitution } from '../../utils/mutations';
+import { DeletionClass, InsertionClass, SubstitutionClass } from '../../utils/mutations';
 
 describe('parseMutation', () => {
     const singleSegmentedReferenceGenome = {
@@ -28,22 +28,22 @@ describe('parseMutation', () => {
             {
                 name: 'should parse nucleotide insertions',
                 input: 'ins_10:ACGT',
-                expected: { type: 'nucleotideInsertions', value: new Insertion(undefined, 10, 'ACGT') },
+                expected: { type: 'nucleotideInsertions', value: new InsertionClass(undefined, 10, 'ACGT') },
             },
             {
                 name: 'should parse amino acid insertions',
                 input: 'ins_gene1:10:ACGT',
-                expected: { type: 'aminoAcidInsertions', value: new Insertion('gene1', 10, 'ACGT') },
+                expected: { type: 'aminoAcidInsertions', value: new InsertionClass('gene1', 10, 'ACGT') },
             },
             {
                 name: 'should parse amino acid insertion with LAPIS-style wildcard',
                 input: 'ins_gene1:10:?AC?GT',
-                expected: { type: 'aminoAcidInsertions', value: new Insertion('gene1', 10, '?AC?GT') },
+                expected: { type: 'aminoAcidInsertions', value: new InsertionClass('gene1', 10, '?AC?GT') },
             },
             {
                 name: 'should parse amino acid insertion with SILO-style wildcard',
                 input: 'ins_gene1:10:.*AC.*GT',
-                expected: { type: 'aminoAcidInsertions', value: new Insertion('gene1', 10, '.*AC.*GT') },
+                expected: { type: 'aminoAcidInsertions', value: new InsertionClass('gene1', 10, '.*AC.*GT') },
             },
             {
                 name: 'should return null for insertion with segment not in reference genome',
@@ -56,32 +56,32 @@ describe('parseMutation', () => {
             {
                 name: 'should parse nucleotide deletion in single segmented reference genome, when no segment is given',
                 input: 'A123-',
-                expected: { type: 'nucleotideMutations', value: new Deletion(undefined, 'A', 123) },
+                expected: { type: 'nucleotideMutations', value: new DeletionClass(undefined, 'A', 123) },
             },
             {
                 name: 'should parse nucleotide deletion without valueAtReference when no segment is given',
                 input: '123-',
-                expected: { type: 'nucleotideMutations', value: new Deletion(undefined, undefined, 123) },
+                expected: { type: 'nucleotideMutations', value: new DeletionClass(undefined, undefined, 123) },
             },
             {
                 name: 'should parse nucleotide deletion',
                 input: 'nuc1:A123-',
-                expected: { type: 'nucleotideMutations', value: new Deletion('nuc1', 'A', 123) },
+                expected: { type: 'nucleotideMutations', value: new DeletionClass('nuc1', 'A', 123) },
             },
             {
                 name: 'should parse nucleotide deletion without valueAtReference',
                 input: 'nuc1:123-',
-                expected: { type: 'nucleotideMutations', value: new Deletion('nuc1', undefined, 123) },
+                expected: { type: 'nucleotideMutations', value: new DeletionClass('nuc1', undefined, 123) },
             },
             {
                 name: 'should parse amino acid deletion',
                 input: 'gene1:A123-',
-                expected: { type: 'aminoAcidMutations', value: new Deletion('gene1', 'A', 123) },
+                expected: { type: 'aminoAcidMutations', value: new DeletionClass('gene1', 'A', 123) },
             },
             {
                 name: 'should parse amino acid deletion without valueAtReference',
                 input: 'gene1:123-',
-                expected: { type: 'aminoAcidMutations', value: new Deletion('gene1', undefined, 123) },
+                expected: { type: 'aminoAcidMutations', value: new DeletionClass('gene1', undefined, 123) },
             },
             {
                 name: 'should return null for deletion with segment not in reference genome',
@@ -93,35 +93,35 @@ describe('parseMutation', () => {
             {
                 name: 'should parse nucleotide substitution in single segmented reference genome, when no segment is given',
                 input: 'A123T',
-                expected: { type: 'nucleotideMutations', value: new Substitution(undefined, 'A', 'T', 123) },
+                expected: { type: 'nucleotideMutations', value: new SubstitutionClass(undefined, 'A', 'T', 123) },
             },
             {
                 name: 'should parse substitution without valueAtReference',
                 input: '123T',
-                expected: { type: 'nucleotideMutations', value: new Substitution(undefined, undefined, 'T', 123) },
+                expected: { type: 'nucleotideMutations', value: new SubstitutionClass(undefined, undefined, 'T', 123) },
             },
             {
                 name: 'should parse substitution with neither valueAtReference not substitutionValue',
                 input: '123',
                 expected: {
                     type: 'nucleotideMutations',
-                    value: new Substitution(undefined, undefined, undefined, 123),
+                    value: new SubstitutionClass(undefined, undefined, undefined, 123),
                 },
             },
             {
                 name: 'should parse a "no mutation" substitution',
                 input: '123.',
-                expected: { type: 'nucleotideMutations', value: new Substitution(undefined, undefined, '.', 123) },
+                expected: { type: 'nucleotideMutations', value: new SubstitutionClass(undefined, undefined, '.', 123) },
             },
             {
                 name: 'should parse nucleotide substitution',
                 input: 'nuc1:A123T',
-                expected: { type: 'nucleotideMutations', value: new Substitution('nuc1', 'A', 'T', 123) },
+                expected: { type: 'nucleotideMutations', value: new SubstitutionClass('nuc1', 'A', 'T', 123) },
             },
             {
                 name: 'should parse amino acid substitution',
                 input: 'gene1:A123T',
-                expected: { type: 'aminoAcidMutations', value: new Substitution('gene1', 'A', 'T', 123) },
+                expected: { type: 'aminoAcidMutations', value: new SubstitutionClass('gene1', 'A', 'T', 123) },
             },
             {
                 name: 'should return null for substitution with segment not in reference genome',

package/src/preact/mutations/getInsertionsTableData.spec.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test } from 'vitest';
 
 import { getInsertionsTableData } from './getInsertionsTableData';
-import { Insertion } from '../../utils/mutations';
+import { InsertionClass } from '../../utils/mutations';
 
 describe('getInsertionsTableData', () => {
     test('should return the correct data', () => {
-        const insertion1 = new Insertion('segment1', 123, 'T');
-        const insertion2 = new Insertion('segment2', 234, 'AAA');
+        const insertion1 = new InsertionClass('segment1', 123, 'T');
+        const insertion2 = new InsertionClass('segment2', 234, 'AAA');
         const data = [
             {
                 type: 'insertion' as const,

package/src/preact/mutations/getMutationsGridData.spec.ts

@@ -1,32 +1,32 @@
 import { describe, expect, test } from 'vitest';
 
 import { type BasesData, getMutationsGridData, type MutationsGridDataRow } from './getMutationsGridData';
-import { Deletion, Substitution } from '../../utils/mutations';
+import { DeletionClass, SubstitutionClass } from '../../utils/mutations';
 
 describe('getMutationsGridData', () => {
     test('should return the correct data', () => {
         const data = [
             {
                 type: 'substitution' as const,
-                mutation: new Substitution(undefined, 'T', 'C', 123),
+                mutation: new SubstitutionClass(undefined, 'T', 'C', 123),
                 count: 1,
                 proportion: 0.9,
             },
             {
                 type: 'substitution' as const,
-                mutation: new Substitution(undefined, 'T', 'C', 234),
+                mutation: new SubstitutionClass(undefined, 'T', 'C', 234),
                 count: 1,
                 proportion: 0.8,
             },
             {
                 type: 'substitution' as const,
-                mutation: new Substitution(undefined, 'T', 'G', 234),
+                mutation: new SubstitutionClass(undefined, 'T', 'G', 234),
                 count: 1,
                 proportion: 0.05,
             },
             {
                 type: 'deletion' as const,
-                mutation: new Deletion(undefined, 'T', 234),
+                mutation: new DeletionClass(undefined, 'T', 234),
                 count: 2,
                 proportion: 0.1,
             },
@@ -70,25 +70,25 @@ describe('getMutationsGridData', () => {
         const data = [
             {
                 type: 'substitution' as const,
-                mutation: new Substitution(undefined, 'T', 'C', 123),
+                mutation: new SubstitutionClass(undefined, 'T', 'C', 123),
                 count: 1,
                 proportion: aboveInterval,
             },
             {
                 type: 'substitution' as const,
-                mutation: new Substitution(undefined, 'T', 'C', 234),
+                mutation: new SubstitutionClass(undefined, 'T', 'C', 234),
                 count: 1,
                 proportion: inInterval,
             },
             {
                 type: 'substitution' as const,
-                mutation: new Substitution(undefined, 'T', 'G', 234),
+                mutation: new SubstitutionClass(undefined, 'T', 'G', 234),
                 count: 1,
                 proportion: belowInterval,
             },
             {
                 type: 'deletion' as const,
-                mutation: new Deletion(undefined, 'T', 234),
+                mutation: new DeletionClass(undefined, 'T', 234),
                 count: 2,
                 proportion: belowInterval,
             },

package/src/preact/mutations/getMutationsTableData.spec.ts

@@ -1,20 +1,20 @@
 import { describe, expect, test } from 'vitest';
 
 import { getMutationsTableData } from './getMutationsTableData';
-import { Deletion, Substitution } from '../../utils/mutations';
+import { DeletionClass, SubstitutionClass } from '../../utils/mutations';
 
 describe('getMutationsTableData', () => {
     test('should not filter anything, when proportions are in interval', () => {
         const data = [
             {
                 type: 'substitution' as const,
-                mutation: new Substitution('segment1', 'A', 'T', 123),
+                mutation: new SubstitutionClass('segment1', 'A', 'T', 123),
                 count: 1,
                 proportion: 0.1,
             },
             {
                 type: 'deletion' as const,
-                mutation: new Deletion('segment2', 'C', 123),
+                mutation: new DeletionClass('segment2', 'C', 123),
                 count: 2,
                 proportion: 0.2,
             },
@@ -32,8 +32,8 @@ describe('getMutationsTableData', () => {
         const aboveInterval = 0.95;
         const inInterval = 0.5;
 
-        const substitutionInInterval = new Substitution('segment1', 'A', 'T', 123);
-        const deletionInInterval = new Deletion('segment2', 'C', 123);
+        const substitutionInInterval = new SubstitutionClass('segment1', 'A', 'T', 123);
+        const deletionInInterval = new DeletionClass('segment2', 'C', 123);
 
         const data = [
             {
@@ -44,7 +44,7 @@ describe('getMutationsTableData', () => {
             },
             {
                 type: 'substitution' as const,
-                mutation: new Substitution('segment1', 'A', 'T', 234),
+                mutation: new SubstitutionClass('segment1', 'A', 'T', 234),
                 count: 1,
                 proportion: belowInterval,
             },
@@ -56,7 +56,7 @@ describe('getMutationsTableData', () => {
             },
             {
                 type: 'deletion' as const,
-                mutation: new Deletion('segment2', 'C', 456),
+                mutation: new DeletionClass('segment2', 'C', 456),
                 count: 2,
                 proportion: aboveInterval,
             },

package/src/preact/mutations/mutations-insertions-table.tsx

@@ -2,7 +2,7 @@ import { type FunctionComponent } from 'preact';
 
 import { getInsertionsTableData } from './getInsertionsTableData';
 import { type InsertionEntry } from '../../types';
-import { type Insertion } from '../../utils/mutations';
+import { type InsertionClass } from '../../utils/mutations';
 import { Table } from '../components/table';
 import { sortInsertions } from '../shared/sort/sortInsertions';
 
@@ -17,11 +17,11 @@ export const InsertionsTable: FunctionComponent<InsertionsTableProps> = ({ data,
             {
                 name: 'Insertion',
                 sort: {
-                    compare: (a: Insertion, b: Insertion) => {
+                    compare: (a: InsertionClass, b: InsertionClass) => {
                         return sortInsertions(a, b);
                     },
                 },
-                formatter: (cell: Insertion) => cell.toString(),
+                formatter: (cell: InsertionClass) => cell.toString(),
             },
             {
                 name: 'Count',

package/src/preact/mutations/mutations-table.tsx

@@ -2,7 +2,7 @@ import { type FunctionComponent } from 'preact';
 
 import { getMutationsTableData } from './getMutationsTableData';
 import { type SubstitutionOrDeletionEntry } from '../../types';
-import { type Deletion, type Substitution } from '../../utils/mutations';
+import { type DeletionClass, type SubstitutionClass } from '../../utils/mutations';
 import type { ProportionInterval } from '../components/proportion-selector';
 import { Table } from '../components/table';
 import { sortSubstitutionsAndDeletions } from '../shared/sort/sortSubstitutionsAndDeletions';
@@ -20,11 +20,11 @@ const MutationsTable: FunctionComponent<MutationsTableProps> = ({ data, proporti
             {
                 name: 'Mutation',
                 sort: {
-                    compare: (a: Substitution | Deletion, b: Substitution | Deletion) => {
+                    compare: (a: SubstitutionClass | DeletionClass, b: SubstitutionClass | DeletionClass) => {
                         return sortSubstitutionsAndDeletions(a, b);
                     },
                 },
-                formatter: (cell: Substitution | Deletion) => cell.toString(),
+                formatter: (cell: SubstitutionClass | DeletionClass) => cell.toString(),
             },
             {
                 name: 'Type',

package/src/preact/mutationsOverTime/MutationOverTimeData.ts

@@ -0,0 +1,20 @@
+import {
+    type MutationOverTimeMutationValue,
+    serializeSubstitutionOrDeletion,
+    serializeTemporal,
+} from '../../query/queryMutationsOverTime';
+import { type Map2d, Map2dBase, type Map2DContents } from '../../utils/map2d';
+import type { Deletion, Substitution } from '../../utils/mutations';
+import type { Temporal } from '../../utils/temporalClass';
+
+export type MutationOverTimeDataMap = Map2d<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>;
+
+export class BaseMutationOverTimeDataMap extends Map2dBase<
+    Substitution | Deletion,
+    Temporal,
+    MutationOverTimeMutationValue
+> {
+    constructor(initialContent?: Map2DContents<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>) {
+        super(serializeSubstitutionOrDeletion, serializeTemporal, initialContent);
+    }
+}