@genspectrum/dashboard-components 1.6.0 → 1.7.0

package/dist/util.d.ts

@@ -194,6 +194,19 @@ declare const mapSourceSchema: default_2.ZodObject<{
     topologyObjectsKey: string;
 }>;
 
+export declare type MeanProportionInterval = default_2.infer<typeof meanProportionIntervalSchema>;
+
+declare const meanProportionIntervalSchema: default_2.ZodObject<{
+    min: default_2.ZodNumber;
+    max: default_2.ZodNumber;
+}, "strip", default_2.ZodTypeAny, {
+    min: number;
+    max: number;
+}, {
+    min: number;
+    max: number;
+}>;
+
 export declare type MutationAnnotation = default_2.infer<typeof mutationAnnotationSchema>;
 
 export declare type MutationAnnotations = default_2.infer<typeof mutationAnnotationsSchema>;
@@ -430,6 +443,17 @@ export declare type MutationsView = default_2.infer<typeof mutationsViewSchema>;
 
 declare const mutationsViewSchema: default_2.ZodUnion<[default_2.ZodLiteral<"table">, default_2.ZodLiteral<"grid">, default_2.ZodLiteral<"insertions">]>;
 
+export declare type MutationType = default_2.infer<typeof mutationTypeSchema>;
+
+export declare const mutationType: {
+    readonly nucleotideMutations: "nucleotideMutations";
+    readonly nucleotideInsertions: "nucleotideInsertions";
+    readonly aminoAcidMutations: "aminoAcidMutations";
+    readonly aminoAcidInsertions: "aminoAcidInsertions";
+};
+
+declare const mutationTypeSchema: default_2.ZodEnum<["nucleotideMutations", "nucleotideInsertions", "aminoAcidMutations", "aminoAcidInsertions"]>;
+
 export declare type NamedLapisFilter = default_2.infer<typeof namedLapisFilterSchema>;
 
 declare const namedLapisFilterSchema: default_2.ZodObject<{
@@ -917,7 +941,7 @@ declare global {
 
 declare global {
     interface HTMLElementTagNameMap {
-        'gs-wastewater-mutations-over-time': WastewaterMutationsOverTimeComponent;
+        'gs-genome-data-viewer': GenomeDataViewerComponent;
     }
 }
 
@@ -925,7 +949,7 @@ declare global {
 declare global {
     namespace JSX {
         interface IntrinsicElements {
-            'gs-wastewater-mutations-over-time': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+            'gs-genome-data-viewer': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
         }
     }
 }
@@ -947,22 +971,6 @@ declare global {
 }
 
 
-declare global {
-    interface HTMLElementTagNameMap {
-        'gs-genome-data-viewer': GenomeDataViewerComponent;
-    }
-}
-
-
-declare global {
-    namespace JSX {
-        interface IntrinsicElements {
-            'gs-genome-data-viewer': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
-        }
-    }
-}
-
-
 declare global {
     interface HTMLElementTagNameMap {
         'gs-mutations': MutationsComponent;
@@ -981,7 +989,7 @@ declare global {
 
 declare global {
     interface HTMLElementTagNameMap {
-        'gs-prevalence-over-time': PrevalenceOverTimeComponent;
+        'gs-relative-growth-advantage': RelativeGrowthAdvantageComponent;
     }
 }
 
@@ -989,7 +997,7 @@ declare global {
 declare global {
     namespace JSX {
         interface IntrinsicElements {
-            'gs-prevalence-over-time': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+            'gs-relative-growth-advantage': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
         }
     }
 }
@@ -997,7 +1005,7 @@ declare global {
 
 declare global {
     interface HTMLElementTagNameMap {
-        'gs-relative-growth-advantage': RelativeGrowthAdvantageComponent;
+        'gs-prevalence-over-time': PrevalenceOverTimeComponent;
     }
 }
 
@@ -1005,7 +1013,7 @@ declare global {
 declare global {
     namespace JSX {
         interface IntrinsicElements {
-            'gs-relative-growth-advantage': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+            'gs-prevalence-over-time': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
         }
     }
 }
@@ -1207,6 +1215,22 @@ declare global {
 }
 
 
+declare global {
+    interface HTMLElementTagNameMap {
+        'gs-wastewater-mutations-over-time': WastewaterMutationsOverTimeComponent;
+    }
+}
+
+
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'gs-wastewater-mutations-over-time': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+        }
+    }
+}
+
+
 declare module 'chart.js' {
     interface CartesianScaleTypeRegistry {
         logit: {

package/dist/util.js

@@ -1,4 +1,4 @@
-import { D, a, L, N, b, T, d, g, v } from "./NumberRangeFilterChangedEvent-CQ32Qy8D.js";
+import { D, a, L, N, b, T, d, g, m, v } from "./NumberRangeFilterChangedEvent-BnPI-Asz.js";
 export {
   D as DateRangeOptionChangedEvent,
   a as LineageFilterChangedEvent,
@@ -8,6 +8,7 @@ export {
   T as TextFilterChangedEvent,
   d as dateRangeOptionPresets,
   g as gsEventNames,
+  m as mutationType,
   v as views
 };
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@genspectrum/dashboard-components",
-    "version": "1.6.0",
+    "version": "1.7.0",
     "description": "GenSpectrum web components for building dashboards",
     "type": "module",
     "license": "AGPL-3.0-only",

package/src/preact/genomeViewer/CDSPlot.tsx

@@ -20,9 +20,16 @@ function getMaxTickNumber(fullWidth: number): number {
 }
 
 function getTicks(zoomStart: number, zoomEnd: number, fullWidth: number) {
-    const maxTickNumber = getMaxTickNumber(fullWidth);
+    let maxTickNumber = getMaxTickNumber(fullWidth);
     const length = zoomEnd - zoomStart;
-    const minTickSize = length / maxTickNumber;
+    let minTickSize = length / maxTickNumber;
+    if (minTickSize <= 1) {
+        maxTickNumber = MIN_TICK_NUMBER;
+        minTickSize = length / maxTickNumber;
+    }
+    if (minTickSize <= 1) {
+        return [];
+    }
     let maxTickSize = 10 ** Math.round(Math.log(minTickSize) / Math.log(10));
     const numTicks = Math.round(length / maxTickSize);
     if (numTicks > maxTickNumber) {
@@ -78,6 +85,7 @@ const XAxis: FunctionComponent<XAxisProps> = (componentProps) => {
                             width: `calc(${widthPercent}% - 1px)`,
                         }}
                     >
+                        {/* TODO(#994): determine if text can be shown based on text width */}
                         {width >= averageWidth ? tick.start : ''}
                     </div>
                 );
@@ -142,6 +150,9 @@ const CDSBars: FunctionComponent<CDSBarsProps> = (componentProps) => {
                                 if (start >= end) {
                                     return null;
                                 }
+                                if (zoomEnd - zoomStart <= 2) {
+                                    return null;
+                                }
 
                                 const widthPercent = ((end - start) / visibleRegionLength) * 100;
                                 const leftPercent = ((start - zoomStart) / visibleRegionLength) * 100;

package/src/preact/genomeViewer/loadGff3.ts

@@ -22,6 +22,12 @@ export async function loadGff3(gff3Source: string, genomeLength: number | undefi
     }
 
     const response = await fetch(gff3Source);
+    if (!response.ok) {
+        throw new UserFacingError(
+            'GFF3 download failed',
+            `Server returned ${response.status} ${response.statusText} for ${response.url}`,
+        );
+    }
     const content = await response.text();
     genomeLength ??= loadGenomeLength(content);
     return { features: parseGFF3(content), length: genomeLength };

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

@@ -6,6 +6,7 @@ import { MutationFilter, type MutationFilterProps } from './mutation-filter';
 import { previewHandles } from '../../../.storybook/preview';
 import { LAPIS_URL } from '../../constants';
 import referenceGenome from '../../lapisApi/__mockData__/referenceGenome.json';
+import { mutationType } from '../../types';
 import { gsEventNames } from '../../utils/gsEventNames';
 import { LapisUrlContextProvider } from '../LapisUrlContext';
 import { ReferenceGenomeContext } from '../ReferenceGenomeContext';
@@ -230,7 +231,7 @@ export const FiltersOutDisabledMutationTypes: StoryObj<MutationFilterProps> = {
     ...Default,
     args: {
         ...Default.args,
-        enabledMutationTypes: ['nucleotideMutations'],
+        enabledMutationTypes: [mutationType.nucleotideMutations],
     },
     play: async ({ canvasElement, step }) => {
         const { canvas, changedListenerMock } = await prepare(canvasElement, step);

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/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/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';