@genspectrum/dashboard-components 1.6.0 → 1.8.0

package/src/preact/mutationFilter/mutation-filter.tsx

@@ -7,7 +7,13 @@ import { getExampleMutation } from './ExampleMutation';
 import { MutationFilterInfo } from './mutation-filter-info';
 import { parseAndValidateMutation } from './parseAndValidateMutation';
 import { type ReferenceGenome } from '../../lapisApi/ReferenceGenome';
-import { type MutationsFilter, mutationsFilterSchema } from '../../types';
+import {
+    type MutationsFilter,
+    mutationsFilterSchema,
+    mutationType,
+    mutationTypeSchema,
+    type MutationType,
+} from '../../types';
 import { gsEventNames } from '../../utils/gsEventNames';
 import { type DeletionClass, type InsertionClass, type SubstitutionClass } from '../../utils/mutations';
 import { ReferenceGenomeContext } from '../ReferenceGenomeContext';
@@ -15,15 +21,6 @@ import { ErrorBoundary } from '../components/error-boundary';
 import { UserFacingError } from '../components/error-display';
 import { singleGraphColorRGBByName } from '../shared/charts/colors';
 
-const mutationTypeSchema = z.enum([
-    'nucleotideMutations',
-    'aminoAcidMutations',
-    'nucleotideInsertions',
-    'aminoAcidInsertions',
-]);
-
-export type MutationType = z.infer<typeof mutationTypeSchema>;
-
 const mutationFilterInnerPropsSchema = z.object({
     initialValue: z.union([mutationsFilterSchema.optional(), z.array(z.string()), z.undefined()]),
     enabledMutationTypes: z.array(mutationTypeSchema).optional(),
@@ -37,22 +34,22 @@ export type MutationFilterInnerProps = z.infer<typeof mutationFilterInnerPropsSc
 export type MutationFilterProps = z.infer<typeof mutationFilterPropsSchema>;
 
 type SelectedNucleotideMutation = {
-    type: 'nucleotideMutations';
+    type: typeof mutationType.nucleotideMutations;
     value: SubstitutionClass | DeletionClass;
 };
 
 type SelectedAminoAcidMutation = {
-    type: 'aminoAcidMutations';
+    type: typeof mutationType.aminoAcidMutations;
     value: SubstitutionClass | DeletionClass;
 };
 
 type SelectedNucleotideInsertion = {
-    type: 'nucleotideInsertions';
+    type: typeof mutationType.nucleotideInsertions;
     value: InsertionClass;
 };
 
 type SelectedAminoAcidInsertion = {
-    type: 'aminoAcidInsertions';
+    type: typeof mutationType.aminoAcidInsertions;
     value: InsertionClass;
 };
 
@@ -80,7 +77,7 @@ export const MutationFilter: FunctionComponent<MutationFilterProps> = (props) =>
 
 function MutationFilterInner({
     initialValue,
-    enabledMutationTypes = ['nucleotideMutations', 'nucleotideInsertions', 'aminoAcidMutations', 'aminoAcidInsertions'],
+    enabledMutationTypes = Object.values(mutationType),
 }: MutationFilterInnerProps) {
     const referenceGenome = useContext(ReferenceGenomeContext);
     const filterRef = useRef<HTMLDivElement>(null);
@@ -309,16 +306,16 @@ function getInitialState(
 function getPlaceholder(referenceGenome: ReferenceGenome, enabledMutationTypes: MutationType[]) {
     const exampleMutationList = [];
 
-    if (enabledMutationTypes.includes('nucleotideMutations')) {
+    if (enabledMutationTypes.includes(mutationType.nucleotideMutations)) {
         exampleMutationList.push(getExampleMutation(referenceGenome, 'nucleotide', 'substitution'));
     }
-    if (enabledMutationTypes.includes('nucleotideInsertions')) {
+    if (enabledMutationTypes.includes(mutationType.nucleotideInsertions)) {
         exampleMutationList.push(getExampleMutation(referenceGenome, 'nucleotide', 'insertion'));
     }
-    if (enabledMutationTypes.includes('aminoAcidMutations')) {
+    if (enabledMutationTypes.includes(mutationType.aminoAcidMutations)) {
         exampleMutationList.push(getExampleMutation(referenceGenome, 'amino acid', 'substitution'));
     }
-    if (enabledMutationTypes.includes('aminoAcidInsertions')) {
+    if (enabledMutationTypes.includes(mutationType.aminoAcidInsertions)) {
         exampleMutationList.push(getExampleMutation(referenceGenome, 'amino acid', 'insertion'));
     }
 
@@ -329,13 +326,13 @@ function getPlaceholder(referenceGenome: ReferenceGenome, enabledMutationTypes:
 
 const backgroundColorMap = (data: MutationFilterItem, alpha: number = 0.4) => {
     switch (data.type) {
-        case 'nucleotideMutations':
+        case mutationType.nucleotideMutations:
             return singleGraphColorRGBByName('green', alpha);
-        case 'aminoAcidMutations':
+        case mutationType.aminoAcidMutations:
             return singleGraphColorRGBByName('teal', alpha);
-        case 'nucleotideInsertions':
+        case mutationType.nucleotideInsertions:
             return singleGraphColorRGBByName('indigo', alpha);
-        case 'aminoAcidInsertions':
+        case mutationType.aminoAcidInsertions:
             return singleGraphColorRGBByName('purple', alpha);
     }
 };
@@ -370,13 +367,13 @@ function mapToMutationFilterStrings(selectedFilters: MutationFilterItem[]) {
     return selectedFilters.reduce<MutationsFilter>(
         (acc, filter) => {
             switch (filter.type) {
-                case 'nucleotideMutations':
+                case mutationType.nucleotideMutations:
                     return { ...acc, nucleotideMutations: [...acc.nucleotideMutations, filter.value.toString()] };
-                case 'aminoAcidMutations':
+                case mutationType.aminoAcidMutations:
                     return { ...acc, aminoAcidMutations: [...acc.aminoAcidMutations, filter.value.toString()] };
-                case 'nucleotideInsertions':
+                case mutationType.nucleotideInsertions:
                     return { ...acc, nucleotideInsertions: [...acc.nucleotideInsertions, filter.value.toString()] };
-                case 'aminoAcidInsertions':
+                case mutationType.aminoAcidInsertions:
                     return { ...acc, aminoAcidInsertions: [...acc.aminoAcidInsertions, filter.value.toString()] };
             }
         },

package/src/preact/mutationFilter/parseAndValidateMutation.ts

@@ -1,7 +1,7 @@
 import { type MutationFilterItem } from './mutation-filter';
 import { sequenceTypeFromSegment } from './sequenceTypeFromSegment';
 import type { ReferenceGenome } from '../../lapisApi/ReferenceGenome';
-import type { SequenceType } from '../../types';
+import { type SequenceType, mutationType } from '../../types';
 import { DeletionClass, InsertionClass, type Mutation, SubstitutionClass } from '../../utils/mutations';
 
 export const parseAndValidateMutation = (
@@ -22,11 +22,11 @@ export const parseAndValidateMutation = (
 
 const getSequenceType = (type: MutationFilterItem['type']) => {
     switch (type) {
-        case 'nucleotideInsertions':
-        case 'nucleotideMutations':
+        case mutationType.nucleotideInsertions:
+        case mutationType.nucleotideMutations:
             return 'nucleotide';
-        case 'aminoAcidInsertions':
-        case 'aminoAcidMutations':
+        case mutationType.aminoAcidInsertions:
+        case mutationType.aminoAcidMutations:
             return 'amino acid';
     }
 };
@@ -37,10 +37,10 @@ const parseMutation = (value: string, referenceGenome: ReferenceGenome): Mutatio
         const sequenceType = sequenceTypeFromSegment(possibleInsertion.segment, referenceGenome);
         switch (sequenceType) {
             case 'nucleotide': {
-                return { type: 'nucleotideInsertions', value: possibleInsertion };
+                return { type: mutationType.nucleotideInsertions, value: possibleInsertion };
             }
             case 'amino acid':
-                return { type: 'aminoAcidInsertions', value: possibleInsertion };
+                return { type: mutationType.aminoAcidInsertions, value: possibleInsertion };
             case undefined:
                 return null;
         }
@@ -51,9 +51,9 @@ const parseMutation = (value: string, referenceGenome: ReferenceGenome): Mutatio
         const sequenceType = sequenceTypeFromSegment(possibleDeletion.segment, referenceGenome);
         switch (sequenceType) {
             case 'nucleotide':
-                return { type: 'nucleotideMutations', value: possibleDeletion };
+                return { type: mutationType.nucleotideMutations, value: possibleDeletion };
             case 'amino acid':
-                return { type: 'aminoAcidMutations', value: possibleDeletion };
+                return { type: mutationType.aminoAcidMutations, value: possibleDeletion };
             case undefined:
                 return null;
         }
@@ -64,10 +64,10 @@ const parseMutation = (value: string, referenceGenome: ReferenceGenome): Mutatio
         const sequenceType = sequenceTypeFromSegment(possibleSubstitution.segment, referenceGenome);
         switch (sequenceType) {
             case 'nucleotide': {
-                return { type: 'nucleotideMutations', value: possibleSubstitution };
+                return { type: mutationType.nucleotideMutations, value: possibleSubstitution };
             }
             case 'amino acid': {
-                return { type: 'aminoAcidMutations', value: possibleSubstitution };
+                return { type: mutationType.aminoAcidMutations, value: possibleSubstitution };
             }
 
             case undefined:

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

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 
 import { parseAndValidateMutation } from './parseAndValidateMutation';
+import { mutationType } from '../../types';
 import { DeletionClass, InsertionClass, SubstitutionClass } from '../../utils/mutations';
 
 describe('parseMutation', () => {
@@ -28,32 +29,32 @@ describe('parseMutation', () => {
             {
                 name: 'should parse nucleotide insertions',
                 input: 'ins_3:ACGT',
-                expected: { type: 'nucleotideInsertions', value: new InsertionClass(undefined, 3, 'ACGT') },
+                expected: { type: mutationType.nucleotideInsertions, value: new InsertionClass(undefined, 3, 'ACGT') },
             },
             {
                 name: 'should parse amino acid insertions',
                 input: 'ins_gene1:3:ACGT',
-                expected: { type: 'aminoAcidInsertions', value: new InsertionClass('gene1', 3, 'ACGT') },
+                expected: { type: mutationType.aminoAcidInsertions, value: new InsertionClass('gene1', 3, 'ACGT') },
             },
             {
                 name: 'should parse amino acid insertions in all upper case',
                 input: 'INS_GENE1:3:ACGT',
-                expected: { type: 'aminoAcidInsertions', value: new InsertionClass('GENE1', 3, 'ACGT') },
+                expected: { type: mutationType.aminoAcidInsertions, value: new InsertionClass('GENE1', 3, 'ACGT') },
             },
             {
                 name: 'should parse amino acid insertions in all lower case',
                 input: 'ins_gene1:3:acgt',
-                expected: { type: 'aminoAcidInsertions', value: new InsertionClass('gene1', 3, 'acgt') },
+                expected: { type: mutationType.aminoAcidInsertions, value: new InsertionClass('gene1', 3, 'acgt') },
             },
             {
                 name: 'should parse amino acid insertion with LAPIS-style wildcard',
                 input: 'ins_gene1:3:?AC?GT',
-                expected: { type: 'aminoAcidInsertions', value: new InsertionClass('gene1', 3, '?AC?GT') },
+                expected: { type: mutationType.aminoAcidInsertions, value: new InsertionClass('gene1', 3, '?AC?GT') },
             },
             {
                 name: 'should parse amino acid insertion with SILO-style wildcard',
                 input: 'ins_gene1:3:.*AC.*GT',
-                expected: { type: 'aminoAcidInsertions', value: new InsertionClass('gene1', 3, '.*AC.*GT') },
+                expected: { type: mutationType.aminoAcidInsertions, value: new InsertionClass('gene1', 3, '.*AC.*GT') },
             },
             {
                 name: 'should return null for insertion with segment not in reference genome',
@@ -71,42 +72,42 @@ describe('parseMutation', () => {
             {
                 name: 'should parse nucleotide deletion in single segmented reference genome, when no segment is given',
                 input: 'A3-',
-                expected: { type: 'nucleotideMutations', value: new DeletionClass(undefined, 'A', 3) },
+                expected: { type: mutationType.nucleotideMutations, value: new DeletionClass(undefined, 'A', 3) },
             },
             {
                 name: 'should parse nucleotide deletion without valueAtReference when no segment is given',
                 input: '3-',
-                expected: { type: 'nucleotideMutations', value: new DeletionClass(undefined, undefined, 3) },
+                expected: { type: mutationType.nucleotideMutations, value: new DeletionClass(undefined, undefined, 3) },
             },
             {
                 name: 'should parse nucleotide deletion',
                 input: 'nuc1:A3-',
-                expected: { type: 'nucleotideMutations', value: new DeletionClass('nuc1', 'A', 3) },
+                expected: { type: mutationType.nucleotideMutations, value: new DeletionClass('nuc1', 'A', 3) },
             },
             {
                 name: 'should parse nucleotide deletion without valueAtReference',
                 input: 'nuc1:3-',
-                expected: { type: 'nucleotideMutations', value: new DeletionClass('nuc1', undefined, 3) },
+                expected: { type: mutationType.nucleotideMutations, value: new DeletionClass('nuc1', undefined, 3) },
             },
             {
                 name: 'should parse amino acid deletion',
                 input: 'gene1:A3-',
-                expected: { type: 'aminoAcidMutations', value: new DeletionClass('gene1', 'A', 3) },
+                expected: { type: mutationType.aminoAcidMutations, value: new DeletionClass('gene1', 'A', 3) },
             },
             {
                 name: 'should parse amino acid deletion in all upper case',
                 input: 'GENE1:A3-',
-                expected: { type: 'aminoAcidMutations', value: new DeletionClass('GENE1', 'A', 3) },
+                expected: { type: mutationType.aminoAcidMutations, value: new DeletionClass('GENE1', 'A', 3) },
             },
             {
                 name: 'should parse amino acid deletion in all lower case',
                 input: 'gene1:a3-',
-                expected: { type: 'aminoAcidMutations', value: new DeletionClass('gene1', 'a', 3) },
+                expected: { type: mutationType.aminoAcidMutations, value: new DeletionClass('gene1', 'a', 3) },
             },
             {
                 name: 'should parse amino acid deletion without valueAtReference',
                 input: 'gene1:3-',
-                expected: { type: 'aminoAcidMutations', value: new DeletionClass('gene1', undefined, 3) },
+                expected: { type: mutationType.aminoAcidMutations, value: new DeletionClass('gene1', undefined, 3) },
             },
             {
                 name: 'should return null for deletion with segment not in reference genome',
@@ -123,45 +124,54 @@ describe('parseMutation', () => {
             {
                 name: 'should parse nucleotide substitution in single segmented reference genome, when no segment is given',
                 input: 'A3T',
-                expected: { type: 'nucleotideMutations', value: new SubstitutionClass(undefined, 'A', 'T', 3) },
+                expected: {
+                    type: mutationType.nucleotideMutations,
+                    value: new SubstitutionClass(undefined, 'A', 'T', 3),
+                },
             },
             {
                 name: 'should parse substitution without valueAtReference',
                 input: '3T',
-                expected: { type: 'nucleotideMutations', value: new SubstitutionClass(undefined, undefined, 'T', 3) },
+                expected: {
+                    type: mutationType.nucleotideMutations,
+                    value: new SubstitutionClass(undefined, undefined, 'T', 3),
+                },
             },
             {
                 name: 'should parse substitution with neither valueAtReference not substitutionValue',
                 input: '3',
                 expected: {
-                    type: 'nucleotideMutations',
+                    type: mutationType.nucleotideMutations,
                     value: new SubstitutionClass(undefined, undefined, undefined, 3),
                 },
             },
             {
                 name: 'should parse a "no mutation" substitution',
                 input: '3.',
-                expected: { type: 'nucleotideMutations', value: new SubstitutionClass(undefined, undefined, '.', 3) },
+                expected: {
+                    type: mutationType.nucleotideMutations,
+                    value: new SubstitutionClass(undefined, undefined, '.', 3),
+                },
             },
             {
                 name: 'should parse nucleotide substitution',
                 input: 'nuc1:A3T',
-                expected: { type: 'nucleotideMutations', value: new SubstitutionClass('nuc1', 'A', 'T', 3) },
+                expected: { type: mutationType.nucleotideMutations, value: new SubstitutionClass('nuc1', 'A', 'T', 3) },
             },
             {
                 name: 'should parse amino acid substitution',
                 input: 'gene1:A3T',
-                expected: { type: 'aminoAcidMutations', value: new SubstitutionClass('gene1', 'A', 'T', 3) },
+                expected: { type: mutationType.aminoAcidMutations, value: new SubstitutionClass('gene1', 'A', 'T', 3) },
             },
             {
                 name: 'should parse amino acid substitution in all upper case',
                 input: 'GENE1:A3T',
-                expected: { type: 'aminoAcidMutations', value: new SubstitutionClass('GENE1', 'A', 'T', 3) },
+                expected: { type: mutationType.aminoAcidMutations, value: new SubstitutionClass('GENE1', 'A', 'T', 3) },
             },
             {
                 name: 'should parse amino acid substitution in all lower case',
                 input: 'gene1:a3t',
-                expected: { type: 'aminoAcidMutations', value: new SubstitutionClass('gene1', 'a', 't', 3) },
+                expected: { type: mutationType.aminoAcidMutations, value: new SubstitutionClass('gene1', 'a', 't', 3) },
             },
             {
                 name: 'should return null for substitution with segment not in reference genome',

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

@@ -5,6 +5,7 @@ import { getMutationsTableData } from './getMutationsTableData';
 import { type SequenceType, type SubstitutionOrDeletionEntry } from '../../types';
 import { type DeletionClass, type SubstitutionClass } from '../../utils/mutations';
 import { useMutationAnnotationsProvider } from '../MutationAnnotationsContext';
+import { useMutationLinkProvider } from '../MutationLinkTemplateContext';
 import { GridJsAnnotatedMutation } from '../components/annotated-mutation';
 import type { ProportionInterval } from '../components/proportion-selector';
 import { Table } from '../components/table';
@@ -29,6 +30,7 @@ const MutationsTable: FunctionComponent<MutationsTableProps> = ({
     sequenceType,
 }) => {
     const annotationsProvider = useMutationAnnotationsProvider();
+    const linkProvider = useMutationLinkProvider();
 
     const headers = [
         {
@@ -43,6 +45,7 @@ const MutationsTable: FunctionComponent<MutationsTableProps> = ({
                     mutation={cell}
                     sequenceType={sequenceType}
                     annotationsProvider={annotationsProvider}
+                    linkProvider={linkProvider}
                 />
             ),
         },

package/src/preact/mutationsOverTime/mutations-over-time.tsx

@@ -47,6 +47,12 @@ import { useWebWorker } from '../webWorkers/useWebWorker';
 const mutationsOverTimeViewSchema = z.literal(views.grid);
 export type MutationsOverTimeView = z.infer<typeof mutationsOverTimeViewSchema>;
 
+const meanProportionIntervalSchema = z.object({
+    min: z.number().min(0).max(1),
+    max: z.number().min(0).max(1),
+});
+export type MeanProportionInterval = z.infer<typeof meanProportionIntervalSchema>;
+
 const mutationOverTimeSchema = z.object({
     lapisFilter: lapisFilterSchema,
     sequenceType: sequenceTypeSchema,
@@ -55,10 +61,7 @@ const mutationOverTimeSchema = z.object({
     lapisDateField: z.string().min(1),
     useNewEndpoint: z.boolean().optional(),
     displayMutations: displayMutationsSchema.optional(),
-    initialMeanProportionInterval: z.object({
-        min: z.number().min(0).max(1),
-        max: z.number().min(0).max(1),
-    }),
+    initialMeanProportionInterval: meanProportionIntervalSchema,
     hideGaps: z.boolean().optional(),
     width: z.string(),
     height: z.string().optional(),

package/src/preact/shared/stories/expectMutationAnnotation.ts

@@ -6,7 +6,9 @@ export async function expectMutationAnnotation(canvasElement: HTMLElement, mutat
     await waitFor(async () => {
         const annotatedMutation = canvas.getAllByText(mutation)[0];
         await expect(annotatedMutation).toBeVisible();
-        await userEvent.click(annotatedMutation);
+        const button = within(annotatedMutation).getByRole('button');
+        await expect(button).toBeVisible();
+        await userEvent.click(button);
     });
 
     await waitFor(() => expect(canvas.getByText(`Annotations for ${mutation}`)).toBeVisible());

package/src/types.ts

@@ -44,7 +44,7 @@ export type SequenceType = z.infer<typeof sequenceTypeSchema>;
 
 export type SubstitutionOrDeletion = 'substitution' | 'deletion';
 
-export type MutationType = SubstitutionOrDeletion | 'insertion';
+export type SubstitutionOrDeletionOrInsertion = SubstitutionOrDeletion | 'insertion';
 
 export type SubstitutionEntry<T extends Substitution = SubstitutionClass> = {
     type: 'substitution';
@@ -79,3 +79,19 @@ export const views = {
     bubble: 'bubble',
     map: 'map',
 } as const;
+
+export const mutationType = {
+    nucleotideMutations: 'nucleotideMutations',
+    nucleotideInsertions: 'nucleotideInsertions',
+    aminoAcidMutations: 'aminoAcidMutations',
+    aminoAcidInsertions: 'aminoAcidInsertions',
+} as const;
+
+export const mutationTypeSchema = z.enum([
+    mutationType.nucleotideMutations,
+    mutationType.nucleotideInsertions,
+    mutationType.aminoAcidMutations,
+    mutationType.aminoAcidInsertions,
+]);
+
+export type MutationType = z.infer<typeof mutationTypeSchema>;

package/src/utilEntrypoint.ts

@@ -12,6 +12,8 @@ export {
     views,
     type TemporalGranularity,
     type MutationsFilter,
+    mutationType,
+    type MutationType,
 } from './types';
 
 export type { MutationComparisonView, MutationComparisonProps } from './preact/mutationComparison/mutation-comparison';
@@ -47,3 +49,5 @@ export {
     NumberRangeFilterChangedEvent,
     NumberRangeValueChangedEvent,
 } from './preact/numberRangeFilter/NumberRangeFilterChangedEvent';
+
+export { type MeanProportionInterval } from './preact/mutationsOverTime/mutations-over-time';

package/src/utils/mutations.spec.ts

@@ -6,6 +6,7 @@ describe('SubstitutionClass', () => {
     it('should be parsed from string', () => {
         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));
+        expect(SubstitutionClass.parse('1')).deep.equal(new SubstitutionClass(undefined, undefined, undefined, 1));
     });
 
     it('should be parsed with stop codons', () => {
@@ -13,6 +14,12 @@ describe('SubstitutionClass', () => {
         expect(SubstitutionClass.parse('S:T1247*')).deep.equal(new SubstitutionClass('S', 'T', '*', 1247));
     });
 
+    it('invalid substitution strings should return null', () => {
+        expect(SubstitutionClass.parse('A1-')).to.equal(null);
+        expect(SubstitutionClass.parse('ins_1:A')).to.equal(null);
+        expect(SubstitutionClass.parse('E34Q')).to.equal(null);
+    });
+
     it('should render to string correctly', () => {
         const substitutions = [
             {
@@ -39,6 +46,12 @@ describe('DeletionClass', () => {
         expect(DeletionClass.parse('seg1:*1-')).deep.equal(new DeletionClass('seg1', '*', 1));
     });
 
+    it('invalid deletion strings should return null', () => {
+        expect(DeletionClass.parse('seg1:A1T')).to.equal(null);
+        expect(DeletionClass.parse('ins_1:A')).to.equal(null);
+        expect(DeletionClass.parse('E34-')).to.equal(null);
+    });
+
     it('should render to string correctly', () => {
         const substitutions = [
             {
@@ -74,4 +87,10 @@ describe('InsertionClass', () => {
     it('should be parsed with stop codon insertion', () => {
         expect(InsertionClass.parse('ins_134:*')).deep.equal(new InsertionClass(undefined, 134, '*'));
     });
+
+    it('invalid insertion strings should return null', () => {
+        expect(InsertionClass.parse('A1-')).to.equal(null);
+        expect(InsertionClass.parse('seg1:A1T')).to.equal(null);
+        expect(InsertionClass.parse('ins_34:Q')).to.equal(null);
+    });
 });

package/src/utils/mutations.ts

@@ -1,9 +1,9 @@
-import { type MutationType, type SequenceType } from '../types';
+import { type SubstitutionOrDeletionOrInsertion, type SequenceType } from '../types';
 
 export interface Mutation {
     readonly position: number;
     readonly code: string;
-    readonly type: MutationType;
+    readonly type: SubstitutionOrDeletionOrInsertion;
     readonly segment?: string;
 }
 
@@ -13,8 +13,28 @@ export interface MutationClass extends Mutation {
     toString(): string;
 }
 
-export const substitutionRegex =
-    /^((?<segment>[A-Z0-9_-]+)(?=:):)?(?<valueAtReference>[A-Z*])?(?<position>\d+)(?<substitutionValue>[A-Z.*])?$/i;
+// Allowed IUPAC characters: https://www.bioinformatics.org/sms/iupac.html
+const nucleotideChars = 'ACGTRYKMSWBDHVN';
+const aminoAcidChars = 'ACDEFGHIKLMNPQRSTVWY';
+
+function segmentPart(type: 'nucleotide' | 'aminoAcid') {
+    return type === 'aminoAcid' ? `(?<segment>[A-Z0-9_-]+):` : `((?<segment>[A-Z0-9_-]+)(?=:):)?`;
+}
+
+function buildSubstitutionRegex(type: 'nucleotide' | 'aminoAcid') {
+    const chars = type === 'nucleotide' ? nucleotideChars : aminoAcidChars;
+
+    return new RegExp(
+        `^${segmentPart(type)}` +
+            `(?<valueAtReference>[${chars}*])?` +
+            `(?<position>\\d+)` +
+            `(?<substitutionValue>[${chars}.*])?$`,
+        'i',
+    );
+}
+
+const nucleotideSubstitutionRegex = buildSubstitutionRegex('nucleotide');
+const aminoAcidSubstitutionRegex = buildSubstitutionRegex('aminoAcid');
 
 export interface Substitution extends Mutation {
     type: 'substitution';
@@ -55,7 +75,9 @@ export class SubstitutionClass implements MutationClass, Substitution {
     }
 
     static parse(mutationStr: string): SubstitutionClass | null {
-        const match = substitutionRegex.exec(mutationStr);
+        const matchNucleotide = nucleotideSubstitutionRegex.exec(mutationStr);
+        const matchAminoAcid = aminoAcidSubstitutionRegex.exec(mutationStr);
+        const match = matchNucleotide ?? matchAminoAcid;
         if (match?.groups === undefined) {
             return null;
         }
@@ -68,7 +90,17 @@ export class SubstitutionClass implements MutationClass, Substitution {
     }
 }
 
-export const deletionRegex = /^((?<segment>[A-Z0-9_-]+)(?=:):)?(?<valueAtReference>[A-Z*])?(?<position>\d+)(-)$/i;
+function buildDeletionRegex(type: 'nucleotide' | 'aminoAcid') {
+    const chars = type === 'nucleotide' ? nucleotideChars : aminoAcidChars;
+
+    return new RegExp(
+        `^${segmentPart(type)}` + `(?<valueAtReference>[${chars}*])?` + `(?<position>\\d+)` + `(-)$`,
+        'i',
+    );
+}
+
+const nucleotideDeletionRegex = buildDeletionRegex('nucleotide');
+const aminoAcidDeletionRegex = buildDeletionRegex('aminoAcid');
 
 export interface Deletion extends Mutation {
     type: 'deletion';
@@ -105,7 +137,9 @@ export class DeletionClass implements MutationClass, Deletion {
     }
 
     static parse(mutationStr: string): DeletionClass | null {
-        const match = deletionRegex.exec(mutationStr);
+        const matchNucleotide = nucleotideDeletionRegex.exec(mutationStr);
+        const matchAminoAcid = aminoAcidDeletionRegex.exec(mutationStr);
+        const match = matchNucleotide ?? matchAminoAcid;
         if (match?.groups === undefined) {
             return null;
         }
@@ -118,8 +152,19 @@ export class DeletionClass implements MutationClass, Deletion {
     }
 }
 
-export const insertionRegexp =
-    /^ins_((?<segment>[A-Z0-9_-]+)(?=:):)?(?<position>\d+):(?<insertedSymbols>(([A-Z?*]|(\.\*))+))$/i;
+function buildInsertionRegex(type: 'nucleotide' | 'aminoAcid') {
+    const chars = type === 'nucleotide' ? nucleotideChars : aminoAcidChars;
+
+    const wildcardToken = `(?:\\.\\*)`;
+
+    return new RegExp(
+        `^ins_${segmentPart(type)}(?<position>\\d+):(?<insertedSymbols>(?:[${chars}?*]|${wildcardToken})+)$`,
+        'i',
+    );
+}
+
+const nucleotideInsertionRegex = buildInsertionRegex('nucleotide');
+const aminoAcidInsertionRegex = buildInsertionRegex('aminoAcid');
 
 export interface Insertion extends Mutation {
     type: 'insertion';
@@ -154,7 +199,9 @@ export class InsertionClass implements MutationClass {
     }
 
     static parse(mutationStr: string): InsertionClass | null {
-        const match = insertionRegexp.exec(mutationStr);
+        const matchNucleotide = nucleotideInsertionRegex.exec(mutationStr);
+        const matchAminoAcid = aminoAcidInsertionRegex.exec(mutationStr);
+        const match = matchNucleotide ?? matchAminoAcid;
         if (match?.groups === undefined) {
             return null;
         }

package/src/web-components/gs-app.spec-d.ts

@@ -2,9 +2,16 @@ import { describe, expectTypeOf, test } from 'vitest';
 
 import { AppComponent } from './gs-app';
 import { type MutationAnnotations } from './mutation-annotations-context';
+import { type MutationLinkTemplate } from './mutation-link-template-context';
 
 describe('gs-app types', () => {
     test('mutationAnnotations type should match', () => {
         expectTypeOf(AppComponent.prototype).toHaveProperty('mutationAnnotations').toEqualTypeOf<MutationAnnotations>();
     });
+
+    test('mutationLinkTemplate type should match', () => {
+        expectTypeOf(AppComponent.prototype)
+            .toHaveProperty('mutationLinkTemplate')
+            .toEqualTypeOf<MutationLinkTemplate>();
+    });
 });