@genspectrum/dashboard-components 1.6.0 → 1.7.0

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/input/gs-mutation-filter.stories.ts

@@ -7,6 +7,7 @@ import { previewHandles } from '../../../.storybook/preview';
 import { LAPIS_URL, REFERENCE_GENOME_ENDPOINT } from '../../constants';
 import '../gs-app';
 import { type MutationFilterProps } from '../../preact/mutationFilter/mutation-filter';
+import { mutationType } from '../../types';
 import { gsEventNames } from '../../utils/gsEventNames';
 import { withinShadowRoot } from '../withinShadowRoot.story';
 import './gs-mutation-filter';
@@ -117,7 +118,7 @@ export const RestrictEnabledMutationTypes: StoryObj<MutationFilterProps> = {
     ...Template,
     args: {
         ...Template.args,
-        enabledMutationTypes: ['nucleotideMutations', 'aminoAcidMutations'],
+        enabledMutationTypes: [mutationType.nucleotideMutations, mutationType.aminoAcidMutations],
     },
     play: async ({ canvasElement }) => {
         const canvas = await withinShadowRoot(canvasElement, 'gs-mutation-filter');

package/src/web-components/input/gs-mutation-filter.tsx

@@ -2,12 +2,8 @@ import { customElement, property } from 'lit/decorators.js';
 import type { DetailedHTMLProps, HTMLAttributes } from 'react';
 
 import { ReferenceGenomesAwaiter } from '../../preact/components/ReferenceGenomesAwaiter';
-import {
-    MutationFilter,
-    type MutationType,
-    type MutationFilterProps,
-} from '../../preact/mutationFilter/mutation-filter';
-import type { MutationsFilter } from '../../types';
+import { MutationFilter, type MutationFilterProps } from '../../preact/mutationFilter/mutation-filter';
+import type { MutationType, MutationsFilter } from '../../types';
 import { type gsEventNames } from '../../utils/gsEventNames';
 import type { Equals, Expect } from '../../utils/typeAssertions';
 import { PreactLitAdapter } from '../PreactLitAdapter';