@genspectrum/dashboard-components 0.6.1 → 0.6.3

package/src/query/queryAggregatedDataOverTime.ts

@@ -7,11 +7,11 @@ import { SlidingOperator } from '../operator/SlidingOperator';
 import { SortOperator } from '../operator/SortOperator';
 import type { LapisFilter, TemporalGranularity } from '../types';
 import {
-    compareTemporal,
+    dateRangeCompare,
     generateAllInRange,
     getMinMaxTemporal,
+    parseDateStringToTemporal,
     type Temporal,
-    TemporalCache,
 } from '../utils/temporal';
 
 export function queryAggregatedDataOverTime<LapisDateField extends string>(
@@ -36,41 +36,16 @@ export function queryAggregatedDataOverTime<LapisDateField extends string>(
     return smoothingWindow >= 1 ? new SlidingOperator(sortData, smoothingWindow, averageSmoothing) : sortData;
 }
 
-function mapDateToGranularityRange(d: { date: string | null; count: number }, granularity: TemporalGranularity) {
-    let dateRange: Temporal | null = null;
-    if (d.date !== null) {
-        const date = TemporalCache.getInstance().getYearMonthDay(d.date);
-        switch (granularity) {
-            case 'day':
-                dateRange = date;
-                break;
-            case 'week':
-                dateRange = date.week;
-                break;
-            case 'month':
-                dateRange = date.month;
-                break;
-            case 'year':
-                dateRange = date.year;
-                break;
-        }
-    }
+export function mapDateToGranularityRange(
+    data: { date: string | null; count: number },
+    granularity: TemporalGranularity,
+) {
     return {
-        dateRange,
-        count: d.count,
+        dateRange: data.date === null ? null : parseDateStringToTemporal(data.date, granularity),
+        count: data.count,
     };
 }
 
-function dateRangeCompare(a: { dateRange: Temporal | null }, b: { dateRange: Temporal | null }) {
-    if (a.dateRange === null) {
-        return 1;
-    }
-    if (b.dateRange === null) {
-        return -1;
-    }
-    return compareTemporal(a.dateRange, b.dateRange);
-}
-
 function averageSmoothing(slidingWindow: { dateRange: Temporal | null; count: number }[]) {
     const average = slidingWindow.reduce((acc, curr) => acc + curr.count, 0) / slidingWindow.length;
     const centerIndex = Math.floor(slidingWindow.length / 2);

package/src/query/queryMutationsOverTime.spec.ts

@@ -0,0 +1,352 @@
+import { describe, expect, it } from 'vitest';
+
+import { queryMutationsOverTimeData } from './queryMutationsOverTime';
+import { DUMMY_LAPIS_URL, lapisRequestMocks } from '../../vitest.setup';
+
+describe('queryMutationsOverTime', () => {
+    it('should fetch for a filter without date', async () => {
+        const lapisFilter = { field1: 'value1', field2: 'value2' };
+        const dateField = 'dateField';
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-01',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.1), getSomeOtherTestMutation(0.4)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.2)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-03',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.3)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray(0)).to.deep.equal([
+            [0.1, 0.2, 0.3],
+            [0.4, 0, 0],
+        ]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+        expect(sequences[1].code).toBe('otherSequenceName:G234C');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-01');
+        expect(dates[1].toString()).toBe('2023-01-02');
+        expect(dates[2].toString()).toBe('2023-01-03');
+    });
+
+    it('should fetch for dates with no mutations', async () => {
+        const lapisFilter = { field1: 'value1', field2: 'value2' };
+        const dateField = 'dateField';
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-01',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.1), getSomeOtherTestMutation(0.4)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-03',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.3)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray(0)).to.deep.equal([
+            [0.1, 0.3, 0],
+            [0.4, 0, 0],
+        ]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+        expect(sequences[1].code).toBe('otherSequenceName:G234C');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-01');
+        expect(dates[1].toString()).toBe('2023-01-03');
+        expect(dates[2].toString()).toBe('2023-01-02');
+    });
+
+    it('should return empty map when no mutations are found', async () => {
+        const lapisFilter = { field1: 'value1', field2: 'value2' };
+        const dateField = 'dateField';
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-01',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-03',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray(0)).to.deep.equal([]);
+        expect(result.getFirstAxisKeys()).to.deep.equal([]);
+        expect(result.getSecondAxisKeys()).to.deep.equal([]);
+    });
+
+    it('should use dateFrom from filter', async () => {
+        const dateField = 'dateField';
+        const lapisFilter = { field1: 'value1', field2: 'value2', [`${dateField}From`]: '2023-01-02' };
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.2)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-03',
+                        dateFieldTo: '2023-01-03',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.3)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray(0)).to.deep.equal([[0.2, 0.3]]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-02');
+        expect(dates[1].toString()).toBe('2023-01-03');
+    });
+
+    it('should use dateTo from filter', async () => {
+        const dateField = 'dateField';
+        const lapisFilter = { field1: 'value1', field2: 'value2', [`${dateField}To`]: '2023-01-02' };
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-01',
+                        dateFieldTo: '2023-01-01',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.1)] },
+                },
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.2)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray(0)).to.deep.equal([[0.1, 0.2]]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-01');
+        expect(dates[1].toString()).toBe('2023-01-02');
+    });
+
+    it('should use date from filter', async () => {
+        const dateField = 'dateField';
+        const lapisFilter = { field1: 'value1', field2: 'value2', [dateField]: '2023-01-02' };
+
+        lapisRequestMocks.aggregated(
+            { ...lapisFilter, fields: [dateField] },
+            {
+                data: [
+                    { count: 1, [dateField]: '2023-01-01' },
+                    { count: 2, [dateField]: '2023-01-03' },
+                ],
+            },
+        );
+
+        lapisRequestMocks.multipleMutations(
+            [
+                {
+                    body: {
+                        ...lapisFilter,
+                        dateFieldFrom: '2023-01-02',
+                        dateFieldTo: '2023-01-02',
+                        minProportion: 0.001,
+                    },
+                    response: { data: [getSomeTestMutation(0.2)] },
+                },
+            ],
+            'nucleotide',
+        );
+
+        const result = await queryMutationsOverTimeData(lapisFilter, 'nucleotide', DUMMY_LAPIS_URL, dateField, 'day');
+
+        expect(result.getAsArray(0)).to.deep.equal([[0.2]]);
+
+        const sequences = result.getFirstAxisKeys();
+        expect(sequences[0].code).toBe('sequenceName:A123T');
+
+        const dates = result.getSecondAxisKeys();
+        expect(dates[0].toString()).toBe('2023-01-02');
+    });
+
+    function getSomeTestMutation(proportion: number) {
+        return {
+            mutation: 'sequenceName:A123T',
+            proportion,
+            count: 1,
+            sequenceName: 'sequenceName',
+            mutationFrom: 'A',
+            mutationTo: 'T',
+            position: 123,
+        };
+    }
+
+    function getSomeOtherTestMutation(proportion: number) {
+        return {
+            mutation: 'otherSequenceName:A123T',
+            proportion,
+            count: 1,
+            sequenceName: 'otherSequenceName',
+            mutationFrom: 'G',
+            mutationTo: 'C',
+            position: 234,
+        };
+    }
+});

package/src/query/queryMutationsOverTime.ts

@@ -0,0 +1,164 @@
+import { mapDateToGranularityRange } from './queryAggregatedDataOverTime';
+import { FetchAggregatedOperator } from '../operator/FetchAggregatedOperator';
+import { FetchSubstitutionsOrDeletionsOperator } from '../operator/FetchSubstitutionsOrDeletionsOperator';
+import { GroupByAndSumOperator } from '../operator/GroupByAndSumOperator';
+import { MapOperator } from '../operator/MapOperator';
+import { RenameFieldOperator } from '../operator/RenameFieldOperator';
+import { SortOperator } from '../operator/SortOperator';
+import {
+    type LapisFilter,
+    type SequenceType,
+    type SubstitutionOrDeletionEntry,
+    type TemporalGranularity,
+} from '../types';
+import { Map2d } from '../utils/Map2d';
+import { type Deletion, type Substitution } from '../utils/mutations';
+import {
+    dateRangeCompare,
+    generateAllInRange,
+    getMinMaxTemporal,
+    parseDateStringToTemporal,
+    type Temporal,
+} from '../utils/temporal';
+
+export type MutationOverTimeData = {
+    date: Temporal;
+    mutations: SubstitutionOrDeletionEntry[];
+};
+
+export type MutationOverTimeMutationValue = number;
+export type MutationOverTimeDataGroupedByMutation = Map2d<
+    Substitution | Deletion,
+    Temporal,
+    MutationOverTimeMutationValue
+>;
+
+export async function queryMutationsOverTimeData(
+    lapisFilter: LapisFilter,
+    sequenceType: 'nucleotide' | 'amino acid',
+    lapis: string,
+    lapisDateField: string,
+    granularity: TemporalGranularity,
+    signal?: AbortSignal,
+) {
+    const allDates = await getDatesInDataset(lapisFilter, lapis, granularity, lapisDateField, signal);
+
+    const subQueries = allDates.map(async (date) => {
+        const dateFrom = date.firstDay.toString();
+        const dateTo = date.lastDay.toString();
+
+        const filter = {
+            ...lapisFilter,
+            [`${lapisDateField}From`]: dateFrom,
+            [`${lapisDateField}To`]: dateTo,
+        };
+
+        const data = await fetchAndPrepareSubstitutionsOrDeletions(filter, sequenceType).evaluate(lapis, signal);
+        return {
+            date,
+            mutations: data.content,
+        };
+    });
+
+    const data = await Promise.all(subQueries);
+
+    return groupByMutation(data);
+}
+
+async function getDatesInDataset(
+    lapisFilter: LapisFilter,
+    lapis: string,
+    granularity: TemporalGranularity,
+    lapisDateField: string,
+    signal: AbortSignal | undefined,
+) {
+    const { content: availableDates } = await queryAvailableDates(
+        lapisFilter,
+        lapis,
+        granularity,
+        lapisDateField,
+        signal,
+    );
+
+    const { dateFrom, dateTo } = getDateRangeFromFilter(lapisFilter, lapisDateField, granularity);
+    const { min, max } = getMinMaxTemporal(availableDates);
+
+    return generateAllInRange(dateFrom ?? min, dateTo ?? max);
+}
+
+function getDateRangeFromFilter(lapisFilter: LapisFilter, lapisDateField: string, granularity: TemporalGranularity) {
+    const valueFromFilter = lapisFilter[lapisDateField] as string | null;
+
+    if (valueFromFilter) {
+        return {
+            dateFrom: parseDateStringToTemporal(valueFromFilter, granularity),
+            dateTo: parseDateStringToTemporal(valueFromFilter, granularity),
+        };
+    }
+
+    const minFromFilter = lapisFilter[`${lapisDateField}From`] as string | null;
+    const maxFromFilter = lapisFilter[`${lapisDateField}To`] as string | null;
+
+    return {
+        dateFrom: minFromFilter ? parseDateStringToTemporal(minFromFilter, granularity) : null,
+        dateTo: maxFromFilter ? parseDateStringToTemporal(maxFromFilter, granularity) : null,
+    };
+}
+
+function queryAvailableDates(
+    lapisFilter: LapisFilter,
+    lapis: string,
+    granularity: TemporalGranularity,
+    lapisDateField: string,
+    signal?: AbortSignal,
+) {
+    return fetchAndPrepareDates(lapisFilter, granularity, lapisDateField).evaluate(lapis, signal);
+}
+
+function fetchAndPrepareDates<LapisDateField extends string>(
+    filter: LapisFilter,
+    granularity: TemporalGranularity,
+    lapisDateField: LapisDateField,
+) {
+    const fetchData = new FetchAggregatedOperator<{ [key in LapisDateField]: string | null }>(filter, [lapisDateField]);
+    const dataWithFixedDateKey = new RenameFieldOperator(fetchData, lapisDateField, 'date');
+    const mapData = new MapOperator(dataWithFixedDateKey, (data) => mapDateToGranularityRange(data, granularity));
+    const groupByData = new GroupByAndSumOperator(mapData, 'dateRange', 'count');
+    const sortData = new SortOperator(groupByData, dateRangeCompare);
+    return new MapOperator(sortData, (data) => data.dateRange);
+}
+
+function fetchAndPrepareSubstitutionsOrDeletions(filter: LapisFilter, sequenceType: SequenceType) {
+    return new FetchSubstitutionsOrDeletionsOperator(filter, sequenceType, 0.001);
+}
+
+export function groupByMutation(data: MutationOverTimeData[]) {
+    const dataArray = new Map2d<Substitution | Deletion, Temporal, number>(
+        (mutation) => mutation.code,
+        (date) => date.toString(),
+    );
+
+    data.forEach((mutationData) => {
+        mutationData.mutations.forEach((mutationEntry) => {
+            dataArray.set(mutationEntry.mutation, mutationData.date, mutationEntry.proportion);
+        });
+    });
+
+    addZeroValuesForDatesWithNoMutationData(dataArray, data);
+
+    return dataArray;
+}
+
+function addZeroValuesForDatesWithNoMutationData(
+    dataArray: Map2d<Substitution | Deletion, Temporal, number>,
+    data: MutationOverTimeData[],
+) {
+    if (dataArray.getFirstAxisKeys().length !== 0) {
+        const someMutation = dataArray.getFirstAxisKeys()[0];
+        data.forEach((mutationData) => {
+            if (mutationData.mutations.length === 0) {
+                dataArray.set(someMutation, mutationData.date, 0);
+            }
+        });
+    }
+}

package/src/query/queryNumberOfSequencesOverTime.ts

@@ -4,7 +4,6 @@ import { sortNullToBeginningThenByDate } from '../utils/sort';
 import { makeArray } from '../utils/utils';
 
 export type NumberOfSequencesDatasets = Awaited<ReturnType<typeof queryNumberOfSequencesOverTime>>;
-export type NumberOfSequencesDataset = NumberOfSequencesDatasets[number];
 
 export async function queryNumberOfSequencesOverTime(
     lapis: string,

package/src/query/queryRelativeGrowthAdvantage.ts

@@ -28,11 +28,11 @@ export async function queryRelativeGrowthAdvantage<LapisDateField extends string
         mapNumerator.evaluate(lapis, signal),
         mapDenominator.evaluate(lapis, signal),
     ]);
-    const minMaxDate = getMinMaxTemporal(denominatorData.content.map((d) => d.date));
-    if (!minMaxDate) {
+    const { min: minDate, max: maxDate } = getMinMaxTemporal(denominatorData.content.map((d) => d.date));
+    if (!minDate && !maxDate) {
         return null;
     }
-    const [minDate, maxDate] = minMaxDate as [YearMonthDay, YearMonthDay];
+
     const numeratorCounts = new Map<YearMonthDay, number>();
     numeratorData.content.forEach((d) => {
         if (d.date) {

package/src/utils/Map2d.ts

@@ -0,0 +1,75 @@
+import hash from 'object-hash';
+
+export class Map2d<Key1 extends object | string, Key2 extends object | string, Value> {
+    readonly data: Map<string, Map<string, Value>> = new Map<string, Map<string, Value>>();
+    readonly keysFirstAxis = new Map<string, Key1>();
+    readonly keysSecondAxis = new Map<string, Key2>();
+
+    constructor(
+        readonly serializeFirstAxis: (key: Key1) => string = (key) => (typeof key === 'string' ? key : hash(key)),
+        readonly serializeSecondAxis: (key: Key2) => string = (key) => (typeof key === 'string' ? key : hash(key)),
+    ) {}
+
+    get(keyFirstAxis: Key1, keySecondAxis: Key2) {
+        const serializedKeyFirstAxis = this.serializeFirstAxis(keyFirstAxis);
+        const serializedKeySecondAxis = this.serializeSecondAxis(keySecondAxis);
+        return this.data.get(serializedKeyFirstAxis)?.get(serializedKeySecondAxis);
+    }
+
+    getRow(key: Key1, fillEmptyWith: Value) {
+        const serializedKeyFirstAxis = this.serializeFirstAxis(key);
+        const row = this.data.get(serializedKeyFirstAxis);
+        if (row === undefined) {
+            return [];
+        }
+        return Array.from(this.keysSecondAxis.keys()).map((key) => row.get(key) ?? fillEmptyWith);
+    }
+
+    set(keyFirstAxis: Key1, keySecondAxis: Key2, value: Value) {
+        const serializedKeyFirstAxis = this.serializeFirstAxis(keyFirstAxis);
+        const serializedKeySecondAxis = this.serializeSecondAxis(keySecondAxis);
+
+        if (!this.data.has(serializedKeyFirstAxis)) {
+            this.data.set(serializedKeyFirstAxis, new Map<string, Value>());
+        }
+
+        this.data.get(serializedKeyFirstAxis)!.set(serializedKeySecondAxis, value);
+
+        this.keysFirstAxis.set(serializedKeyFirstAxis, keyFirstAxis);
+        this.keysSecondAxis.set(serializedKeySecondAxis, keySecondAxis);
+    }
+
+    deleteRow(key: Key1) {
+        const serializedKeyFirstAxis = this.serializeFirstAxis(key);
+        this.data.delete(serializedKeyFirstAxis);
+        this.keysFirstAxis.delete(serializedKeyFirstAxis);
+    }
+
+    getFirstAxisKeys() {
+        return Array.from(this.keysFirstAxis.values());
+    }
+
+    getSecondAxisKeys() {
+        return Array.from(this.keysSecondAxis.values());
+    }
+
+    getAsArray(fillEmptyWith: Value) {
+        return this.getFirstAxisKeys().map((firstAxisKey) => {
+            return this.getSecondAxisKeys().map((secondAxisKey) => {
+                return this.get(firstAxisKey, secondAxisKey) ?? fillEmptyWith;
+            });
+        });
+    }
+
+    copy() {
+        const copy = new Map2d<Key1, Key2, Value>(this.serializeFirstAxis, this.serializeSecondAxis);
+        this.data.forEach((value, key) => {
+            const keyFirstAxis = this.keysFirstAxis.get(key);
+            value.forEach((value, key) => {
+                const keySecondAxis = this.keysSecondAxis.get(key);
+                copy.set(keyFirstAxis!, keySecondAxis!, value);
+            });
+        });
+        return copy;
+    }
+}