@genspectrum/dashboard-components 0.6.18 → 0.7.0

package/src/preact/shared/sort/sortInsertions.spec.ts

@@ -1,20 +1,20 @@
 import { describe, expect, test } from 'vitest';
 
 import { sortInsertions } from './sortInsertions';
-import { Insertion } from '../../../utils/mutations';
+import { InsertionClass } from '../../../utils/mutations';
 
 describe('sortInsertions with no segments', () => {
     test('should sort for positions first', () => {
-        const a = new Insertion(undefined, 1, 'A');
-        const b = new Insertion(undefined, 2, 'A');
+        const a = new InsertionClass(undefined, 1, 'A');
+        const b = new InsertionClass(undefined, 2, 'A');
 
         expect(sortInsertions(a, b)).toBeLessThan(0);
         expect(sortInsertions(b, a)).toBeGreaterThan(0);
     });
 
     test('should sort for symbols second', () => {
-        const a = new Insertion(undefined, 1, 'A');
-        const b = new Insertion(undefined, 1, 'B');
+        const a = new InsertionClass(undefined, 1, 'A');
+        const b = new InsertionClass(undefined, 1, 'B');
 
         expect(sortInsertions(a, b)).toBeLessThan(0);
         expect(sortInsertions(b, a)).toBeGreaterThan(0);
@@ -23,24 +23,24 @@ describe('sortInsertions with no segments', () => {
 
 describe('sortInsertions with segments', () => {
     test('should sort for segments first', () => {
-        const a = new Insertion('AA1', 1, 'A');
-        const b = new Insertion('BB1', 1, 'A');
+        const a = new InsertionClass('AA1', 1, 'A');
+        const b = new InsertionClass('BB1', 1, 'A');
 
         expect(sortInsertions(a, b)).toBeLessThan(0);
         expect(sortInsertions(b, a)).toBeGreaterThan(0);
     });
 
     test('should sort for positions second', () => {
-        const a = new Insertion('AA1', 1, 'A');
-        const b = new Insertion('AA1', 2, 'A');
+        const a = new InsertionClass('AA1', 1, 'A');
+        const b = new InsertionClass('AA1', 2, 'A');
 
         expect(sortInsertions(a, b)).toBeLessThan(0);
         expect(sortInsertions(b, a)).toBeGreaterThan(0);
     });
 
     test('should sort for symbols third', () => {
-        const a = new Insertion('AA1', 1, 'A');
-        const b = new Insertion('AA1', 1, 'B');
+        const a = new InsertionClass('AA1', 1, 'A');
+        const b = new InsertionClass('AA1', 1, 'B');
 
         expect(sortInsertions(a, b)).toBeLessThan(0);
         expect(sortInsertions(b, a)).toBeGreaterThan(0);

package/src/preact/shared/sort/sortInsertions.ts

@@ -1,7 +1,7 @@
 import { comparePositions, compareSegments } from './sortSubstitutionsAndDeletions';
-import { type Insertion } from '../../../utils/mutations';
+import { type InsertionClass } from '../../../utils/mutations';
 
-export const sortInsertions = (a: Insertion, b: Insertion) => {
+export const sortInsertions = (a: InsertionClass, b: InsertionClass) => {
     if (a.segment !== b.segment) {
         return compareSegments(a.segment, b.segment);
     }

package/src/preact/shared/sort/sortSubstitutionsAndDeletions.spec.ts

@@ -1,28 +1,28 @@
 import { describe, expect, test } from 'vitest';
 
 import { sortSubstitutionsAndDeletions } from './sortSubstitutionsAndDeletions';
-import { Deletion, Substitution } from '../../../utils/mutations';
+import { DeletionClass, SubstitutionClass } from '../../../utils/mutations';
 
 describe('sortSubstitutionsAndDeletions with no segments', () => {
     test('should sort for positions first', () => {
-        const a = new Substitution(undefined, 'A', 'B', 123);
-        const b = new Substitution(undefined, 'A', 'B', 234);
+        const a = new SubstitutionClass(undefined, 'A', 'B', 123);
+        const b = new SubstitutionClass(undefined, 'A', 'B', 234);
 
         expect(sortSubstitutionsAndDeletions(a, b)).toBeLessThan(0);
         expect(sortSubstitutionsAndDeletions(b, a)).toBeGreaterThan(0);
     });
 
     test('should sort for substitutionValue second', () => {
-        const a = new Substitution(undefined, 'A', 'A', 123);
-        const b = new Substitution(undefined, 'A', 'B', 123);
+        const a = new SubstitutionClass(undefined, 'A', 'A', 123);
+        const b = new SubstitutionClass(undefined, 'A', 'B', 123);
 
         expect(sortSubstitutionsAndDeletions(a, b)).toBeLessThan(0);
         expect(sortSubstitutionsAndDeletions(b, a)).toBeGreaterThan(0);
     });
 
     test('should sort for substitutionValue over deletion', () => {
-        const a = new Substitution(undefined, 'A', 'A', 123);
-        const b = new Deletion(undefined, 'A', 123);
+        const a = new SubstitutionClass(undefined, 'A', 'A', 123);
+        const b = new DeletionClass(undefined, 'A', 123);
 
         expect(sortSubstitutionsAndDeletions(a, b)).toBeLessThan(0);
         expect(sortSubstitutionsAndDeletions(b, a)).toBeGreaterThan(0);
@@ -31,24 +31,24 @@ describe('sortSubstitutionsAndDeletions with no segments', () => {
 
 describe('sortSubstitutionsAndDeletions with segments', () => {
     test('should sort for segment first', () => {
-        const a = new Substitution('AA1', 'A', 'B', 123);
-        const b = new Substitution('BB1', 'A', 'B', 123);
+        const a = new SubstitutionClass('AA1', 'A', 'B', 123);
+        const b = new SubstitutionClass('BB1', 'A', 'B', 123);
 
         expect(sortSubstitutionsAndDeletions(a, b)).toBeLessThan(0);
         expect(sortSubstitutionsAndDeletions(b, a)).toBeGreaterThan(0);
     });
 
     test('should sort for position second', () => {
-        const a = new Substitution('AA1', 'A', 'B', 123);
-        const b = new Substitution('AA1', 'A', 'B', 234);
+        const a = new SubstitutionClass('AA1', 'A', 'B', 123);
+        const b = new SubstitutionClass('AA1', 'A', 'B', 234);
 
         expect(sortSubstitutionsAndDeletions(a, b)).toBeLessThan(0);
         expect(sortSubstitutionsAndDeletions(b, a)).toBeGreaterThan(0);
     });
 
     test('should sort for substitutionValue third', () => {
-        const a = new Substitution('AA1', 'A', 'A', 123);
-        const b = new Substitution('AA1', 'A', 'B', 123);
+        const a = new SubstitutionClass('AA1', 'A', 'A', 123);
+        const b = new SubstitutionClass('AA1', 'A', 'B', 123);
 
         expect(sortSubstitutionsAndDeletions(a, b)).toBeLessThan(0);
         expect(sortSubstitutionsAndDeletions(b, a)).toBeGreaterThan(0);

package/src/preact/shared/sort/sortSubstitutionsAndDeletions.ts

@@ -1,6 +1,9 @@
-import { Deletion, type Substitution } from '../../../utils/mutations';
+import { DeletionClass, type SubstitutionClass } from '../../../utils/mutations';
 
-export const sortSubstitutionsAndDeletions = (a: Substitution | Deletion, b: Substitution | Deletion) => {
+export const sortSubstitutionsAndDeletions = (
+    a: SubstitutionClass | DeletionClass,
+    b: SubstitutionClass | DeletionClass,
+) => {
     if (a.segment !== b.segment) {
         return compareSegments(a.segment, b.segment);
     }
@@ -9,8 +12,8 @@ export const sortSubstitutionsAndDeletions = (a: Substitution | Deletion, b: Sub
         return comparePositions(a.position, b.position);
     }
 
-    const aIsDeletion = a instanceof Deletion;
-    const bIsDeletion = b instanceof Deletion;
+    const aIsDeletion = a instanceof DeletionClass;
+    const bIsDeletion = b instanceof DeletionClass;
 
     if (aIsDeletion !== bIsDeletion) {
         return aIsDeletion ? 1 : -1;

package/src/preact/webWorkers/useWebWorker.ts

@@ -0,0 +1,51 @@
+import { useEffect, useMemo, useState } from 'preact/hooks';
+
+export function useWebWorker<Request, Response>(messageToWorker: Request, worker: Worker) {
+    const [data, setData] = useState<Response | undefined>(undefined);
+    const [error, setError] = useState<Error | undefined>(undefined);
+    const [isLoading, setIsLoading] = useState(true);
+
+    useEffect(() => {
+        worker.onmessage = (
+            event: MessageEvent<{
+                status: 'loading' | 'success' | 'error';
+                data?: Response;
+                error?: Error;
+            }>,
+        ) => {
+            const { status, data, error } = event.data;
+
+            switch (status) {
+                case 'loading':
+                    setIsLoading(true);
+                    break;
+                case 'success':
+                    setData(data);
+                    setError(undefined);
+                    setIsLoading(false);
+                    break;
+                case 'error':
+                    setError(error);
+                    setIsLoading(false);
+                    break;
+                default:
+                    throw new Error(`Unknown status: ${status}`);
+            }
+        };
+
+        worker.onmessageerror = (event: MessageEvent) => {
+            setError(new Error(`Worker received a message that it cannot deserialize: ${event.data}`));
+            setIsLoading(false);
+        };
+
+        return () => {
+            worker.terminate();
+        };
+    }, []);
+
+    useMemo(() => {
+        worker.postMessage(messageToWorker);
+    }, [messageToWorker]);
+
+    return { data, error, isLoading };
+}

package/src/preact/webWorkers/workerFunction.ts

@@ -0,0 +1,14 @@
+export async function workerFunction<R>(queryFunction: () => R) {
+    try {
+        postMessage({ status: 'loading' });
+
+        const workerResponse = await queryFunction();
+
+        postMessage({
+            status: 'success',
+            data: workerResponse,
+        });
+    } catch (error) {
+        postMessage({ status: 'error', error });
+    }
+}

package/src/query/queryAggregatedDataOverTime.ts

@@ -11,8 +11,8 @@ import {
     generateAllInRange,
     getMinMaxTemporal,
     parseDateStringToTemporal,
-    type Temporal,
-} from '../utils/temporal';
+    type TemporalClass,
+} from '../utils/temporalClass';
 
 export function queryAggregatedDataOverTime<LapisDateField extends string>(
     filter: LapisFilter,
@@ -46,7 +46,7 @@ export function mapDateToGranularityRange(
     };
 }
 
-function averageSmoothing(slidingWindow: { dateRange: Temporal | null; count: number }[]) {
+function averageSmoothing(slidingWindow: { dateRange: TemporalClass | null; count: number }[]) {
     const average = slidingWindow.reduce((acc, curr) => acc + curr.count, 0) / slidingWindow.length;
     const centerIndex = Math.floor(slidingWindow.length / 2);
     return { dateRange: slidingWindow[centerIndex].dateRange, count: average };