@genspectrum/dashboard-components 0.6.18 → 0.6.19

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

@@ -1,28 +1,9 @@
 import { type Meta, type StoryObj } from '@storybook/preact';
 import { expect, waitFor } from '@storybook/test';
 
-import aggregated_01 from './__mockData__/aggregated_2024_01.json';
-import aggregated_02 from './__mockData__/aggregated_2024_02.json';
-import aggregated_03 from './__mockData__/aggregated_2024_03.json';
-import aggregated_04 from './__mockData__/aggregated_2024_04.json';
-import aggregated_05 from './__mockData__/aggregated_2024_05.json';
-import aggregated_06 from './__mockData__/aggregated_2024_06.json';
-import aggregated_07 from './__mockData__/aggregated_2024_07.json';
-import aggregated_date from './__mockData__/aggregated_date.json';
-import aggregated_tooManyMutations from './__mockData__/aggregated_tooManyMutations.json';
-import aggregated_tooManyMutations_total from './__mockData__/aggregated_tooManyMutations_total.json';
-import nucleotideMutation_01 from './__mockData__/nucleotideMutations_2024_01.json';
-import nucleotideMutation_02 from './__mockData__/nucleotideMutations_2024_02.json';
-import nucleotideMutation_03 from './__mockData__/nucleotideMutations_2024_03.json';
-import nucleotideMutation_04 from './__mockData__/nucleotideMutations_2024_04.json';
-import nucleotideMutation_05 from './__mockData__/nucleotideMutations_2024_05.json';
-import nucleotideMutation_06 from './__mockData__/nucleotideMutations_2024_06.json';
-import nucleotideMutation_07 from './__mockData__/nucleotideMutations_2024_07.json';
-import nucleotideMutation_tooManyMutations from './__mockData__/nucleotideMutations_tooManyMutations.json';
 import { MutationsOverTime, type MutationsOverTimeProps } from './mutations-over-time';
-import { AGGREGATED_ENDPOINT, LAPIS_URL, NUCLEOTIDE_MUTATIONS_ENDPOINT } from '../../constants';
+import { LAPIS_URL } from '../../constants';
 import referenceGenome from '../../lapisApi/__mockData__/referenceGenome.json';
-import nucleotideMutations_byMonthOverall from '../../preact/mutationsOverTime/__mockData__/nucleotideMutations_byMonthOverall.json';
 import { LapisUrlContext } from '../LapisUrlContext';
 import { ReferenceGenomeContext } from '../ReferenceGenomeContext';
 
@@ -47,6 +28,9 @@ const meta: Meta<MutationsOverTimeProps> = {
         },
         lapisDateField: { control: 'text' },
     },
+    parameters: {
+        fetchMock: {},
+    },
 };
 
 export default meta;
@@ -69,6 +53,7 @@ const Template = {
     ),
 };
 
+// This test uses mock data: defaultMockData.ts (through mutationOverTimeWorker.mock.ts)
 export const Default: StoryObj<MutationsOverTimeProps> = {
     ...Template,
     args: {
@@ -80,270 +65,9 @@ export const Default: StoryObj<MutationsOverTimeProps> = {
         granularity: 'month',
         lapisDateField: 'date',
     },
-    parameters: {
-        fetchMock: {
-            mocks: [
-                {
-                    matcher: {
-                        name: 'aggregated_dates',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2024-01-15',
-                            dateTo: '2024-07-10',
-                            fields: ['date'],
-                            pangoLineage: 'JN.1*',
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_date,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'aggregated_01',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2024-01-01',
-                            dateTo: '2024-01-31',
-                            fields: [],
-                            pangoLineage: 'JN.1*',
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_01,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'aggregated_02',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2024-02-01',
-                            dateTo: '2024-02-29',
-                            fields: [],
-                            pangoLineage: 'JN.1*',
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_02,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'aggregated_03',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2024-03-01',
-                            dateTo: '2024-03-31',
-                            fields: [],
-                            pangoLineage: 'JN.1*',
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_03,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'aggregated_04',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2024-04-01',
-                            dateTo: '2024-04-30',
-                            fields: [],
-                            pangoLineage: 'JN.1*',
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_04,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'aggregated_05',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2024-05-01',
-                            dateTo: '2024-05-31',
-                            fields: [],
-                            pangoLineage: 'JN.1*',
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_05,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'aggregated_06',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2024-06-01',
-                            dateTo: '2024-06-30',
-                            fields: [],
-                            pangoLineage: 'JN.1*',
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_06,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'aggregated_07',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2024-07-01',
-                            dateTo: '2024-07-31',
-                            fields: [],
-                            pangoLineage: 'JN.1*',
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_07,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'nucleotideMutations_overall',
-                        url: NUCLEOTIDE_MUTATIONS_ENDPOINT,
-                        body: {
-                            pangoLineage: 'JN.1*',
-                            dateFrom: '2024-01-15',
-                            dateTo: '2024-07-10',
-                            minProportion: 0.001,
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: nucleotideMutations_byMonthOverall,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'nucleotideMutations_01',
-                        url: NUCLEOTIDE_MUTATIONS_ENDPOINT,
-                        body: {
-                            pangoLineage: 'JN.1*',
-                            dateFrom: '2024-01-01',
-                            dateTo: '2024-01-31',
-                            minProportion: 0.001,
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: nucleotideMutation_01,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'nucleotideMutations_02',
-                        url: NUCLEOTIDE_MUTATIONS_ENDPOINT,
-                        body: {
-                            pangoLineage: 'JN.1*',
-                            dateFrom: '2024-02-01',
-                            dateTo: '2024-02-29',
-                            minProportion: 0.001,
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: nucleotideMutation_02,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'nucleotideMutations_03',
-                        url: NUCLEOTIDE_MUTATIONS_ENDPOINT,
-                        body: {
-                            pangoLineage: 'JN.1*',
-                            dateFrom: '2024-03-01',
-                            dateTo: '2024-03-31',
-                            minProportion: 0.001,
-                        },
-                        response: {
-                            status: 200,
-                            body: nucleotideMutation_03,
-                        },
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'nucleotideMutations_04',
-                        url: NUCLEOTIDE_MUTATIONS_ENDPOINT,
-                        body: {
-                            pangoLineage: 'JN.1*',
-                            dateFrom: '2024-04-01',
-                            dateTo: '2024-04-30',
-                            minProportion: 0.001,
-                        },
-                        response: {
-                            status: 200,
-                            body: nucleotideMutation_04,
-                        },
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'nucleotideMutations_05',
-                        url: NUCLEOTIDE_MUTATIONS_ENDPOINT,
-                        body: {
-                            pangoLineage: 'JN.1*',
-                            dateFrom: '2024-05-01',
-                            dateTo: '2024-05-31',
-                            minProportion: 0.001,
-                        },
-                        response: {
-                            status: 200,
-                            body: nucleotideMutation_05,
-                        },
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'nucleotideMutations_06',
-                        url: NUCLEOTIDE_MUTATIONS_ENDPOINT,
-                        body: {
-                            pangoLineage: 'JN.1*',
-                            dateFrom: '2024-06-01',
-                            dateTo: '2024-06-30',
-                            minProportion: 0.001,
-                        },
-                        response: {
-                            status: 200,
-                            body: nucleotideMutation_06,
-                        },
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'nucleotideMutations_07',
-                        url: NUCLEOTIDE_MUTATIONS_ENDPOINT,
-                        body: {
-                            pangoLineage: 'JN.1*',
-                            dateFrom: '2024-07-01',
-                            dateTo: '2024-07-31',
-                            minProportion: 0.001,
-                        },
-                        response: {
-                            status: 200,
-                            body: nucleotideMutation_07,
-                        },
-                    },
-                },
-            ],
-        },
-    },
 };
 
+// This test uses mock data: showMessagWhenTooManyMutations.ts (through mutationOverTimeWorker.mock.ts)
 export const ShowsMessageWhenTooManyMutations: StoryObj<MutationsOverTimeProps> = {
     ...Template,
     args: {
@@ -355,58 +79,9 @@ export const ShowsMessageWhenTooManyMutations: StoryObj<MutationsOverTimeProps>
         granularity: 'year',
         lapisDateField: 'date',
     },
-    parameters: {
-        fetchMock: {
-            mocks: [
-                {
-                    matcher: {
-                        name: 'aggregated',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2023-01-01',
-                            dateTo: '2023-12-31',
-                            fields: ['date'],
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_tooManyMutations,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'aggregated_total',
-                        url: AGGREGATED_ENDPOINT,
-                        body: {
-                            dateFrom: '2023-01-01',
-                            dateTo: '2023-12-31',
-                            fields: [],
-                        },
-                    },
-                    response: {
-                        status: 200,
-                        body: aggregated_tooManyMutations_total,
-                    },
-                },
-                {
-                    matcher: {
-                        name: 'nucleotideMutations',
-                        url: NUCLEOTIDE_MUTATIONS_ENDPOINT,
-                        body: {
-                            dateFrom: '2023-01-01',
-                            dateTo: '2023-12-31',
-                            minProportion: 0.001,
-                        },
-                        response: {
-                            status: 200,
-                            body: nucleotideMutation_tooManyMutations,
-                        },
-                    },
-                },
-            ],
-        },
-    },
     play: async ({ canvas }) => {
-        await waitFor(() => expect(canvas.getByText('Showing 100 of 137 mutations.', { exact: false })).toBeVisible());
+        await waitFor(() => expect(canvas.getByText('Showing 100 of 137 mutations.', { exact: false })).toBeVisible(), {
+            timeout: 10000,
+        });
     },
 };

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

@@ -1,22 +1,26 @@
 import { type FunctionComponent } from 'preact';
 import { type Dispatch, type StateUpdater, useContext, useMemo, useState } from 'preact/hooks';
 
+// @ts-expect-error -- uses subpath imports and vite worker import
+import MutationOverTimeWorker from '#mutationOverTime?worker&inline';
 import { getFilteredMutationOverTimeData } from './getFilteredMutationsOverTimeData';
+import { type MutationOverTimeWorkerResponse } from './mutationOverTimeWorker';
 import MutationsOverTimeGrid from './mutations-over-time-grid';
-import { type Dataset } from '../../operator/Dataset';
 import {
-    type MutationOverTimeDataGroupedByMutation,
-    queryMutationsOverTimeData,
-    queryOverallMutationData,
+    type MutationOverTimeMutationValue,
+    type MutationOverTimeQuery,
+    serializeSubstitutionOrDeletion,
+    serializeTemporal,
 } from '../../query/queryMutationsOverTime';
 import {
-    type DeletionEntry,
     type LapisFilter,
     type SequenceType,
-    type SubstitutionEntry,
+    type SubstitutionOrDeletionEntry,
     type TemporalGranularity,
 } from '../../types';
-import { compareTemporal } from '../../utils/temporal';
+import { type Map2d, Map2dBase } from '../../utils/map2d';
+import { type Deletion, type Substitution } from '../../utils/mutations';
+import { type Temporal, toTemporalClass } from '../../utils/temporalClass';
 import { LapisUrlContext } from '../LapisUrlContext';
 import { type ColorScale } from '../components/color-scale-selector';
 import { ColorScaleSelectorDropdown } from '../components/color-scale-selector-dropdown';
@@ -33,8 +37,7 @@ import { ProportionSelectorDropdown } from '../components/proportion-selector-dr
 import { ResizeContainer } from '../components/resize-container';
 import { type DisplayedSegment, SegmentSelector, useDisplayedSegments } from '../components/segment-selector';
 import Tabs from '../components/tabs';
-import { sortSubstitutionsAndDeletions } from '../shared/sort/sortSubstitutionsAndDeletions';
-import { useQuery } from '../useQuery';
+import { useWebWorker } from '../webWorkers/useWebWorker';
 
 export type View = 'grid';
 
@@ -71,41 +74,53 @@ export const MutationsOverTimeInner: FunctionComponent<MutationsOverTimeInnerPro
     lapisDateField,
 }) => {
     const lapis = useContext(LapisUrlContext);
-    const { data, error, isLoading } = useQuery(async () => {
-        const [mutationOverTimeData, overallMutationData] = await Promise.all([
-            queryMutationsOverTimeData(lapisFilter, sequenceType, lapis, lapisDateField, granularity),
-            queryOverallMutationData(lapisFilter, sequenceType, lapis),
-        ]);
-        return { mutationOverTimeData, overallMutationData };
-    }, [lapisFilter, sequenceType, lapis, granularity, lapisDateField]);
+
+    const { data, error, isLoading } = useWebWorker<MutationOverTimeQuery, MutationOverTimeWorkerResponse>(
+        {
+            lapisFilter,
+            sequenceType,
+            granularity,
+            lapisDateField,
+            lapis,
+        },
+        new MutationOverTimeWorker() as Worker,
+    );
 
     if (isLoading) {
         return <LoadingDisplay />;
     }
 
-    if (error !== null) {
+    if (error !== undefined) {
         return <ErrorDisplay error={error} />;
     }
 
-    if (data === null) {
+    if (data === null || data === undefined) {
         return <NoDataDisplay />;
     }
 
+    const { overallMutationData, mutationOverTimeSerialized } = data;
+    const mutationOverTimeData = new Map2dBase(
+        serializeSubstitutionOrDeletion,
+        serializeTemporal,
+        mutationOverTimeSerialized,
+    );
     return (
         <MutationsOverTimeTabs
-            overallMutationData={data.overallMutationData}
-            mutationOverTimeData={data.mutationOverTimeData}
+            overallMutationData={overallMutationData}
+            mutationOverTimeData={mutationOverTimeData}
             sequenceType={sequenceType}
             views={views}
         />
     );
 };
 
+export type MutationOverTimeData = Map2d<Substitution | Deletion, Temporal, MutationOverTimeMutationValue>;
+
 type MutationOverTimeTabsProps = {
-    mutationOverTimeData: MutationOverTimeDataGroupedByMutation;
+    mutationOverTimeData: MutationOverTimeData;
     sequenceType: SequenceType;
     views: View[];
-    overallMutationData: Dataset<SubstitutionEntry | DeletionEntry>;
+    overallMutationData: SubstitutionOrDeletionEntry<Substitution, Deletion>[];
 };
 
 const MutationsOverTimeTabs: FunctionComponent<MutationOverTimeTabsProps> = ({
@@ -123,19 +138,23 @@ const MutationsOverTimeTabs: FunctionComponent<MutationOverTimeTabsProps> = ({
         { label: 'Deletions', checked: true, type: 'deletion' },
     ]);
 
-    const filteredData = useMemo(
-        () =>
-            getFilteredMutationOverTimeData(
-                mutationOverTimeData,
-                overallMutationData,
-                displayedSegments,
-                displayedMutationTypes,
-                proportionInterval,
-            ),
-        [mutationOverTimeData, overallMutationData, displayedSegments, displayedMutationTypes, proportionInterval],
-    );
+    const filteredData = useMemo(() => {
+        return getFilteredMutationOverTimeData(
+            mutationOverTimeData,
+            overallMutationData,
+            displayedSegments,
+            displayedMutationTypes,
+            proportionInterval,
+        );
+    }, [mutationOverTimeData, overallMutationData, displayedSegments, displayedMutationTypes, proportionInterval]);
 
     const getTab = (view: View) => {
+        if (filteredData === undefined) {
+            return {
+                title: 'Calculating',
+                content: <LoadingDisplay />,
+            };
+        }
         switch (view) {
             case 'grid':
                 return {
@@ -173,7 +192,7 @@ type ToolbarProps = {
     setDisplayedMutationTypes: (types: DisplayedMutationType[]) => void;
     proportionInterval: ProportionInterval;
     setProportionInterval: Dispatch<StateUpdater<ProportionInterval>>;
-    filteredData: MutationOverTimeDataGroupedByMutation;
+    filteredData: MutationOverTimeData;
     colorScale: ColorScale;
     setColorScale: Dispatch<StateUpdater<ColorScale>>;
 };
@@ -217,22 +236,19 @@ const Toolbar: FunctionComponent<ToolbarProps> = ({
     );
 };
 
-function getDownloadData(filteredData: MutationOverTimeDataGroupedByMutation) {
-    const dates = filteredData.getSecondAxisKeys().sort((a, b) => compareTemporal(a, b));
-
-    return filteredData
-        .getFirstAxisKeys()
-        .sort(sortSubstitutionsAndDeletions)
-        .map((mutation) => {
-            return dates.reduce(
-                (accumulated, date) => {
-                    const proportion = filteredData.get(mutation, date)?.proportion ?? 0;
-                    return {
-                        ...accumulated,
-                        [date.toString()]: proportion,
-                    };
-                },
-                { mutation: mutation.toString() },
-            );
-        });
+function getDownloadData(filteredData: MutationOverTimeData) {
+    const dates = filteredData.getSecondAxisKeys().map((date) => toTemporalClass(date));
+
+    return filteredData.getFirstAxisKeys().map((mutation) => {
+        return dates.reduce(
+            (accumulated, date) => {
+                const proportion = filteredData.get(mutation, date)?.proportion ?? 0;
+                return {
+                    ...accumulated,
+                    [date.dateString]: proportion,
+                };
+            },
+            { mutation: mutation.code },
+        );
+    });
 }

package/src/preact/numberSequencesOverTime/getNumberOfSequencesOverTimeTableData.ts

@@ -1,5 +1,5 @@
 import type { NumberOfSequencesDatasets } from '../../query/queryNumberOfSequencesOverTime';
-import { generateAllInRange, getMinMaxTemporal, type Temporal } from '../../utils/temporal';
+import { generateAllInRange, getMinMaxTemporal, type TemporalClass } from '../../utils/temporalClass';
 
 type TableRow<DateRangeKey extends string> = { [K in DateRangeKey]: string } & { [key: string]: number };
 
@@ -14,14 +14,14 @@ export const getNumberOfSequencesOverTimeTableData = <DateRangeKey extends strin
 
     const allDateRangesThatOccurInData = datasetsWithCountByDate
         .map(({ content }) => [...content.values()].map((datum) => datum.dateRange))
-        .reduce((acc, keys) => new Set([...acc, ...keys]), new Set<Temporal | null>());
+        .reduce((acc, keys) => new Set([...acc, ...keys]), new Set<TemporalClass | null>());
 
     const minMax = getMinMaxTemporal(allDateRangesThatOccurInData);
     if (minMax === null) {
         return [];
     }
 
-    const allDateRanges: (Temporal | null)[] = generateAllInRange(minMax.min, minMax.max);
+    const allDateRanges: (TemporalClass | null)[] = generateAllInRange(minMax.min, minMax.max);
 
     if (allDateRangesThatOccurInData.has(null)) {
         allDateRanges.unshift(null);

package/src/preact/prevalenceOverTime/getPrevalenceOverTimeTableData.spec.ts

@@ -3,7 +3,7 @@ import { describe, expect, it } from 'vitest';
 import { getPrevalenceOverTimeTableData } from './getPrevalenceOverTimeTableData';
 import { type PrevalenceOverTimeData } from '../../query/queryPrevalenceOverTime';
 import { type TemporalGranularity } from '../../types';
-import { TemporalCache, YearMonthDay } from '../../utils/temporal';
+import { TemporalCache, YearMonthDayClass } from '../../utils/temporalClass';
 
 describe('getPrevalenceOverTimeTableData', () => {
     it('should flatten the data to CSV format', () => {
@@ -12,13 +12,13 @@ describe('getPrevalenceOverTimeTableData', () => {
                 displayName: 'Test 1',
                 content: [
                     {
-                        dateRange: new YearMonthDay(2021, 1, 1, TemporalCache.getInstance()),
+                        dateRange: new YearMonthDayClass(2021, 1, 1, TemporalCache.getInstance()),
                         prevalence: 0.5,
                         count: 100,
                         total: -5,
                     },
                     {
-                        dateRange: new YearMonthDay(2021, 1, 2, TemporalCache.getInstance()),
+                        dateRange: new YearMonthDayClass(2021, 1, 2, TemporalCache.getInstance()),
                         prevalence: 0.6,
                         count: 200,
                         total: -5,
@@ -29,13 +29,13 @@ describe('getPrevalenceOverTimeTableData', () => {
                 displayName: 'Test 2',
                 content: [
                     {
-                        dateRange: new YearMonthDay(2021, 1, 1, TemporalCache.getInstance()),
+                        dateRange: new YearMonthDayClass(2021, 1, 1, TemporalCache.getInstance()),
                         prevalence: 0.7,
                         count: 300,
                         total: -5,
                     },
                     {
-                        dateRange: new YearMonthDay(2021, 1, 2, TemporalCache.getInstance()),
+                        dateRange: new YearMonthDayClass(2021, 1, 2, TemporalCache.getInstance()),
                         prevalence: 0.8,
                         count: 400,
                         total: -5,

package/src/preact/prevalenceOverTime/prevalence-over-time-bubble-chart.tsx

@@ -2,7 +2,7 @@ import { Chart, type ChartConfiguration, registerables } from 'chart.js';
 
 import { maxInData } from './prevalence-over-time';
 import { type PrevalenceOverTimeData } from '../../query/queryPrevalenceOverTime';
-import { addUnit, minusTemporal } from '../../utils/temporal';
+import { addUnit, minusTemporal } from '../../utils/temporalClass';
 import { getMinMaxNumber } from '../../utils/utils';
 import GsChart from '../components/chart';
 import { LogitScale } from '../shared/charts/LogitScale';

package/src/preact/relativeGrowthAdvantage/relative-growth-advantage-chart.tsx

@@ -1,6 +1,6 @@
 import { Chart, type ChartConfiguration, registerables, type TooltipItem } from 'chart.js';
 
-import { type YearMonthDay } from '../../utils/temporal';
+import { type YearMonthDayClass } from '../../utils/temporalClass';
 import GsChart from '../components/chart';
 import { LogitScale } from '../shared/charts/LogitScale';
 import { singleGraphColorRGBByName } from '../shared/charts/colors';
@@ -10,7 +10,7 @@ import { getYAxisScale, type ScaleType } from '../shared/charts/getYAxisScale';
 import { formatProportion } from '../shared/table/formatProportion';
 
 interface RelativeGrowthAdvantageChartData {
-    t: YearMonthDay[];
+    t: YearMonthDayClass[];
     proportion: number[];
     ciLower: number[];
     ciUpper: number[];