@genspectrum/dashboard-components 0.1.1

package/src/query/queryRelativeGrowthAdvantage.ts

@@ -0,0 +1,131 @@
+import { FetchAggregatedOperator } from '../operator/FetchAggregatedOperator';
+import { MapOperator } from '../operator/MapOperator';
+import { type LapisFilter } from '../types';
+import { getMinMaxTemporal, TemporalCache, type YearMonthDay } from '../utils/temporal';
+
+export type RelativeGrowthAdvantageData = Awaited<ReturnType<typeof queryRelativeGrowthAdvantage>>;
+
+export async function queryRelativeGrowthAdvantage(
+    numerator: LapisFilter,
+    denominator: LapisFilter,
+    generationTime: number,
+    lapis: string,
+    signal?: AbortSignal,
+) {
+    const fetchNumerator = new FetchAggregatedOperator<{
+        date: string | null;
+    }>(numerator, ['date']);
+    const fetchDenominator = new FetchAggregatedOperator<{
+        date: string | null;
+    }>(denominator, ['date']);
+    const mapNumerator = new MapOperator(fetchNumerator, toYearMonthDay);
+    const mapDenominator = new MapOperator(fetchDenominator, toYearMonthDay);
+    const [numeratorData, denominatorData] = await Promise.all([
+        mapNumerator.evaluate(lapis, signal),
+        mapDenominator.evaluate(lapis, signal),
+    ]);
+    const minMaxDate = getMinMaxTemporal(denominatorData.content.map((d) => d.date));
+    if (!minMaxDate) {
+        return null;
+    }
+    const [minDate, maxDate] = minMaxDate as [YearMonthDay, YearMonthDay];
+    const numeratorCounts = new Map<YearMonthDay, number>();
+    numeratorData.content.forEach((d) => {
+        if (d.date) {
+            numeratorCounts.set(d.date, d.count);
+        }
+    });
+    const denominatorCounts = new Map<YearMonthDay, number>();
+    const requestData = {
+        t: [] as number[],
+        n: [] as number[],
+        k: [] as number[],
+    };
+    denominatorData.content.forEach((d) => {
+        if (d.date) {
+            denominatorCounts.set(d.date, d.count);
+            const t = d.date.minus(minDate);
+            requestData.t.push(t);
+            requestData.n.push(d.count);
+            requestData.k.push(numeratorCounts.get(d.date) ?? 0);
+        }
+    });
+    const requestPayload = {
+        config: {
+            alpha: 0.95,
+            generationTime,
+            initialCasesVariant: 1,
+            initialCasesWildtype: 1,
+            reproductionNumberWildtype: 1,
+            tStart: 0,
+            tEnd: maxDate.minus(minDate),
+        },
+        data: requestData,
+    };
+    const response = await fetch('https://cov-spectrum.org/api/v2/computed/model/chen2021Fitness', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(requestPayload),
+        signal,
+    });
+    const responseData = (await response.json()) as {
+        estimatedAbsoluteNumbers: {
+            t: number[];
+            variantCases: number[];
+            wildtypeCases: number[];
+        };
+        estimatedProportions: {
+            t: number[];
+            proportion: number[];
+            ciLower: number[];
+            ciUpper: number[];
+        };
+        params: {
+            a: {
+                value: number;
+                ciLower: number;
+                ciUpper: number;
+            };
+            fc: {
+                value: number;
+                ciLower: number;
+                ciUpper: number;
+            };
+            fd: {
+                value: number;
+                ciLower: number;
+                ciUpper: number;
+            };
+            t0: {
+                value: number;
+                ciLower: number;
+                ciUpper: number;
+            };
+        };
+    };
+    const transformed = {
+        ...responseData,
+        estimatedProportions: {
+            ...responseData.estimatedProportions,
+            t: responseData.estimatedProportions.t.map((t) => minDate.addDays(t)),
+        },
+    };
+    const observedProportions = transformed.estimatedProportions.t.map(
+        (t) => (numeratorCounts.get(t) ?? 0) / (denominatorCounts.get(t) ?? 0),
+    );
+
+    return {
+        ...transformed,
+        observedProportions,
+    };
+}
+
+function toYearMonthDay(d: { date: string | null; count: number }) {
+    const temporalCache = TemporalCache.getInstance();
+    return {
+        date: d.date ? temporalCache.getYearMonthDay(d.date) : null,
+        count: d.count,
+    };
+}

package/src/query/querySubstitutionsOrDeletions.ts

@@ -0,0 +1,19 @@
+import { FetchSubstitutionsOrDeletionsOperator } from '../operator/FetchSubstitutionsOrDeletionsOperator';
+import { SortOperator } from '../operator/SortOperator';
+import { type LapisFilter, type SequenceType } from '../types';
+
+export function querySubstitutionsOrDeletions(
+    variant: LapisFilter,
+    sequenceType: SequenceType,
+    lapis: string,
+    signal?: AbortSignal,
+) {
+    const fetchData = new FetchSubstitutionsOrDeletionsOperator(variant, sequenceType, 0);
+    const sortData = new SortOperator(fetchData, (a, b) => {
+        if (a.mutation.segment !== b.mutation.segment) {
+            return (a.mutation.segment ?? '').localeCompare(b.mutation.segment ?? '');
+        }
+        return a.mutation.position - b.mutation.position;
+    });
+    return sortData.evaluate(lapis, signal);
+}

package/src/styles/tailwind.css

@@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;

package/src/styles/tailwind.d.ts

@@ -0,0 +1,3 @@
+declare module '*.css';
+declare module '*.css?inline';
+declare module '*.html';

package/src/types.ts

@@ -0,0 +1,23 @@
+import { type Deletion, type Insertion, type Substitution } from './utils/mutations';
+
+export type LapisFilter = Record<string, string | number | null | boolean>;
+
+export type NamedLapisFilter = LapisFilter & { displayName: string };
+
+export type TemporalGranularity = 'day' | 'week' | 'month' | 'year';
+
+export type SequenceType = 'nucleotide' | 'amino acid';
+
+export type SubstitutionOrDeletion = 'substitution' | 'deletion';
+
+export type MutationType = SubstitutionOrDeletion | 'insertion';
+
+export type SubstitutionEntry = { type: 'substitution'; mutation: Substitution; count: number; proportion: number };
+
+export type DeletionEntry = { type: 'deletion'; mutation: Deletion; count: number; proportion: number };
+
+export type InsertionEntry = { type: 'insertion'; mutation: Insertion; count: number };
+
+export type SubstitutionOrDeletionEntry = SubstitutionEntry | DeletionEntry;
+
+export type MutationEntry = SubstitutionEntry | DeletionEntry | InsertionEntry;

package/src/utils/mutations.spec.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+
+import { Deletion, Insertion, Substitution } from './mutations';
+
+describe('Substitution', () => {
+    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));
+    });
+
+    it('should render to string correctly', () => {
+        const substitutions = [
+            {
+                substitution: new Substitution(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' },
+        ];
+
+        for (const { substitution, expected } of substitutions) {
+            expect(substitution.toString()).to.equal(expected);
+        }
+    });
+});
+
+describe('Deletion', () => {
+    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));
+    });
+
+    it('should render to string correctly', () => {
+        const substitutions = [
+            {
+                deletion: new Deletion(undefined, 'A', 1),
+                expected: 'A1-',
+            },
+            { deletion: new Deletion('segment', 'A', 1), expected: 'segment:A1-' },
+            { deletion: new Deletion(undefined, undefined, 1), expected: '1-' },
+        ];
+
+        for (const { deletion, expected } of substitutions) {
+            expect(deletion.toString()).to.equal(expected);
+        }
+    });
+});
+
+describe('Insertion', () => {
+    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'));
+    });
+
+    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'));
+    });
+
+    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'));
+    });
+});

package/src/utils/mutations.ts

@@ -0,0 +1,165 @@
+import { type SequenceType } from '../types';
+
+export interface Mutation {
+    readonly segment: string | undefined;
+    readonly position: number;
+    readonly code: string;
+
+    equals(other: Mutation): boolean;
+
+    toString(): string;
+}
+
+export const substitutionRegex =
+    /^((?<segment>[A-Za-z0-9_-]+)(?=:):)?(?<valueAtReference>[A-Za-z])?(?<position>\d+)(?<substitutionValue>[A-Za-z.])?$/;
+
+export class Substitution implements Mutation {
+    readonly code;
+
+    constructor(
+        readonly segment: string | undefined,
+        readonly valueAtReference: string | undefined,
+        readonly substitutionValue: string | undefined,
+        readonly position: number,
+    ) {
+        const segmentString = this.segment ? `${this.segment}:` : '';
+        const valueAtReferenceString = this.valueAtReference ? `${this.valueAtReference}` : '';
+        const substitutionValueString = this.substitutionValue ? `${this.substitutionValue}` : '';
+        this.code = `${segmentString}${valueAtReferenceString}${this.position}${substitutionValueString}`;
+    }
+
+    equals(other: Mutation): boolean {
+        if (!(other instanceof Substitution)) {
+            return false;
+        }
+        return (
+            this.segment === other.segment &&
+            this.valueAtReference === other.valueAtReference &&
+            this.substitutionValue === other.substitutionValue &&
+            this.position === other.position
+        );
+    }
+
+    toString() {
+        return this.code;
+    }
+
+    static parse(mutationStr: string): Substitution | null {
+        const match = mutationStr.match(substitutionRegex);
+        if (match === null || match.groups === undefined) {
+            return null;
+        }
+        return new Substitution(
+            match.groups.segment,
+            match.groups.valueAtReference,
+            match.groups.substitutionValue,
+            parseInt(match.groups.position, 10),
+        );
+    }
+}
+
+export const deletionRegex = /^((?<segment>[A-Za-z0-9_-]+)(?=:):)?(?<valueAtReference>[A-Za-z])?(?<position>\d+)(-)$/;
+
+export class Deletion implements Mutation {
+    readonly code;
+
+    constructor(
+        readonly segment: string | undefined,
+        readonly valueAtReference: string | undefined,
+        readonly position: number,
+    ) {
+        const segmentString = this.segment ? `${this.segment}:` : '';
+        const valueAtReferenceString = this.valueAtReference ? `${this.valueAtReference}` : '';
+        this.code = `${segmentString}${valueAtReferenceString}${this.position}-`;
+    }
+
+    equals(other: Mutation): boolean {
+        if (!(other instanceof Deletion)) {
+            return false;
+        }
+        return (
+            this.segment === other.segment &&
+            this.valueAtReference === other.valueAtReference &&
+            this.position === other.position
+        );
+    }
+
+    toString() {
+        return this.code;
+    }
+
+    static parse(mutationStr: string): Deletion | 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));
+    }
+}
+
+export const insertionRegexp =
+    /^ins_((?<segment>[A-Za-z0-9_-]+)(?=:):)?(?<position>\d+):(?<insertedSymbols>(([A-Za-z?]|(\.\*))+))$/i;
+
+export class Insertion implements Mutation {
+    readonly code;
+
+    constructor(
+        readonly segment: string | undefined,
+        readonly position: number,
+        readonly insertedSymbols: string,
+    ) {
+        this.code = `ins_${this.segment ? `${this.segment}:` : ''}${this.position}:${this.insertedSymbols}`;
+    }
+
+    equals(other: Mutation): boolean {
+        if (!(other instanceof Insertion)) {
+            return false;
+        }
+        return (
+            this.segment === other.segment &&
+            this.insertedSymbols === other.insertedSymbols &&
+            this.position === other.position
+        );
+    }
+
+    toString() {
+        return this.code;
+    }
+
+    static parse(mutationStr: string): Insertion | 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);
+    }
+}
+
+export const bases: { [P in SequenceType]: string[] } = {
+    nucleotide: ['A', 'C', 'G', 'T', '-'],
+    'amino acid': [
+        'I',
+        'L',
+        'V',
+        'F',
+        'M',
+        'C',
+        'A',
+        'G',
+        'P',
+        'T',
+        'S',
+        'Y',
+        'W',
+        'Q',
+        'N',
+        'H',
+        'E',
+        'D',
+        'K',
+        'R',
+        '-',
+    ],
+};

package/src/utils/temporal.spec.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+    generateAllDaysInRange,
+    generateAllMonthsInRange,
+    generateAllYearsInRange,
+    TemporalCache,
+    Year,
+    YearMonth,
+    YearMonthDay,
+    YearWeek,
+} from './temporal';
+
+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)),
+        ).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),
+        ]);
+    });
+});
+
+describe('generateAllMonthsInRange', () => {
+    it('should return all months in range', () => {
+        expect(
+            generateAllMonthsInRange(YearMonth.parse('2020-01', cache), YearMonth.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),
+        ]);
+    });
+});
+
+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),
+        ]);
+    });
+});
+
+describe('YearMonthDay', () => {
+    it('should parse from string', () => {
+        const underTest = YearMonthDay.parse('2020-01-01', cache);
+
+        expect(underTest.yearNumber).equal(2020);
+        expect(underTest.monthNumber).equal(1);
+        expect(underTest.dayNumber).equal(1);
+        // seems to be a bug in dayjs: https://github.com/iamkun/dayjs/issues/2620
+        expect(underTest.week.text).equal('2019-01');
+        expect(underTest.text).equal('2020-01-01');
+    });
+});
+
+describe('YearWeek', () => {
+    it('should parse from string', () => {
+        const underTest = YearWeek.parse('2020-02', cache);
+
+        expect(underTest.isoYearNumber).equal(2020);
+        expect(underTest.isoWeekNumber).equal(2);
+        expect(underTest.firstDay.text).equal('2020-01-06');
+        expect(underTest.text).equal('2020-02');
+    });
+});
+
+describe('YearMonth', () => {
+    it('should parse from string', () => {
+        const underTest = YearMonth.parse('2020-01', cache);
+
+        expect(underTest.yearNumber).equal(2020);
+        expect(underTest.monthNumber).equal(1);
+        expect(underTest.text).equal('2020-01');
+        expect(underTest.firstDay.text).equal('2020-01-01');
+    });
+});
+
+describe('Year', () => {
+    it('should parse from string', () => {
+        const underTest = Year.parse('2020', cache);
+
+        expect(underTest.year).equal(2020);
+        expect(underTest.text).equal('2020');
+        expect(underTest.firstDay.text).equal('2020-01-01');
+        expect(underTest.firstMonth.text).equal('2020-01');
+    });
+});