cleaning

website/src/lib/engine/backend/tauri.ts

@@ -159,8 +159,6 @@ export async function createTauriBackend(): Promise<Backend> {
             (await invoke('file_statistics', { fileId })) ?? undefined,
         waypoint: async (fileId, waypointId) =>
             (await invoke('waypoint', { fileId, waypointId })) ?? undefined,
-        trackpoint: async (fileId, segmentId, index) =>
-            (await invoke('trackpoint', { fileId, segmentId, index })) ?? undefined,
         export_file: async (fileId, time, hr, cad, atemp, power, osm) => {
             const file = await optionalArray('export_file', Uint8Array, {
                 fileId,

website/src/lib/engine/backend/types.ts

@@ -8,7 +8,6 @@ import type {
     Selection,
     SelectionPoint,
     StorageOpened,
-    TrackpointDetails,
     WaypointDetails,
 } from 'gpx-wasm';
 import type { ExportOptions, MergeType, SelectMode, SplitType } from '../types';
@@ -266,11 +265,6 @@ export interface Backend {
     file_structure(fileId: string): Promise<FileStructure | undefined>;
     file_statistics(fileId: string): Promise<GlobalStatistics | undefined>;
     waypoint(fileId: string, waypointId: string): Promise<WaypointDetails | undefined>;
-    trackpoint(
-        fileId: string,
-        segmentId: string,
-        index: number
-    ): Promise<TrackpointDetails | undefined>;
     /** A file as GPX (UTF-8 bytes), `undefined` if it does not exist. */
     export_file(
         fileId: string,

website/src/lib/engine/backend/wasm.ts

@@ -123,7 +123,6 @@ export async function createWasmBackend(): Promise<Backend> {
         file_structure: lift(w.file_structure),
         file_statistics: lift(w.file_statistics),
         waypoint: lift(w.waypoint),
-        trackpoint: lift(w.trackpoint),
         // a copy out of the memory of the engine, so a plain ArrayBuffer
         export_file: lift(
             (...args: Parameters<Backend['export_file']>) =>

website/src/lib/engine/engine.ts

@@ -33,7 +33,6 @@ import {
     type FolderEntry,
     type UnsavedChoice,
     type WorkspaceState,
-    type TrackpointDetails,
     type WaypointDetails,
 } from './types';
 
@@ -881,15 +880,6 @@ class Engine {
         return this.read((b) => b.waypoint(fileId, waypointId), undefined);
     }
 
-    /** A trackpoint of a segment, `undefined` if it does not exist. */
-    trackpoint(
-        fileId: string,
-        segmentId: string,
-        index: number
-    ): Promise<TrackpointDetails | undefined> {
-        return this.read((b) => b.trackpoint(fileId, segmentId, index), undefined);
-    }
-
     /**
      * A file as GPX (UTF-8 bytes), `undefined` if it does not exist. The options say which data of the
      * trackpoints to keep.
@@ -935,17 +925,6 @@ class Engine {
         return this.read((b) => b.reduction_distances(), new Float64Array());
     }
 
-    // Coordinates, as flat [lng, lat, ...] arrays: copies.
-    // Refetch them when the `rev` of the segment (or the `waypointsRev` of the file) changed.
-
-    segmentCoordinates(segmentId: string): Promise<Float64Array> {
-        return this.read((b) => b.segment_coordinates(segmentId), new Float64Array());
-    }
-
-    waypointCoordinates(fileId: string): Promise<Float64Array> {
-        return this.read((b) => b.waypoint_coordinates(fileId), new Float64Array());
-    }
-
     /**
      * Registers a consumer of the statistics that needs some of the metrics that are not part of
      * them by default (see `StatisticsMetric`). The metrics asked for by all the consumers are

website/src/lib/engine/selection-helpers.test.ts

@@ -9,7 +9,6 @@ import {
     hasSelectionWithin,
     isCovered,
     isInClipboard,
-    isEmpty,
     isSelected,
     isSelectionHidden,
     selectedElementIds,
@@ -68,12 +67,6 @@ describe('selection helpers', () => {
         }
     });
 
-    it('tells whether the selection is empty', () => {
-        assert.equal(isEmpty(empty), true);
-        assert.equal(isEmpty(files('F1')), false);
-        assert.equal(isEmpty(waypoints), false);
-    });
-
     it('lists the files holding something selected', () => {
         assert.deepEqual(selectedFileIds(empty), []);
         assert.deepEqual(selectedFileIds(files('F1', 'F2')), ['F1', 'F2']);

website/src/lib/engine/selection-helpers.ts

@@ -65,10 +65,6 @@ export function coversSegments(selection: Selection): boolean {
     );
 }
 
-export function isEmpty(selection: Selection): boolean {
-    return selection.type === 'empty';
-}
-
 /** Ids of the files holding something selected (or selected themselves). */
 export function selectedFileIds(selection: Selection): string[] {
     switch (selection.type) {

website/src/lib/engine/trackpoint-categories.test.ts

@@ -3,52 +3,30 @@ import assert from 'node:assert/strict';
 import {
     categoryIntervals,
     categoryValue,
-    categoryValues,
     intervalAt,
     type CategoryIntervals,
 } from '$lib/engine/trackpoint-categories';
 
-describe('categoryValues', () => {
-    // asphalt, asphalt, unknown, gravel, gravel, gravel, unknown
-    const intervals: CategoryIntervals = {
-        starts: new Uint32Array([0, 2, 3, 6]),
-        values: new Uint8Array([1, 0, 2, 0]),
-        names: ['asphalt', 'gravel'],
-    };
-
-    it('is the name of the value of the interval of each trackpoint', () => {
-        assert.deepEqual(categoryValues(intervals, 7), [
-            'asphalt',
-            'asphalt',
-            undefined,
-            'gravel',
-            'gravel',
-            'gravel',
-            undefined,
-        ]);
-    });
-
-    it('goes on with the last interval until the last trackpoint', () => {
-        const last = { ...intervals, values: new Uint8Array([1, 0, 2, 2]) };
-        assert.deepEqual(categoryValues(last, 9).slice(5), [
-            'gravel',
-            'gravel',
-            'gravel',
-            'gravel',
-        ]);
-    });
-
-    it('does not go past the trackpoints', () => {
-        assert.deepEqual(categoryValues(intervals, 3), ['asphalt', 'asphalt', undefined]);
-        assert.deepEqual(categoryValues(intervals, 0), []);
-    });
-
-    it('is undefined without intervals, or for a code without name', () => {
-        assert.deepEqual(categoryValues(undefined, 2), [undefined, undefined]);
-        const unnamed = { starts: new Uint32Array([0]), values: new Uint8Array([3]), names: [] };
-        assert.deepEqual(categoryValues(unnamed, 2), [undefined, undefined]);
-    });
-});
+/** The value of each of the `length` trackpoints, to compare with what is expected. */
+function categoryValues(
+    intervals: CategoryIntervals | undefined,
+    length: number
+): (string | undefined)[] {
+    const result: (string | undefined)[] = new Array(length).fill(undefined);
+    if (!intervals) {
+        return result;
+    }
+    const { starts, values, names } = intervals;
+    for (let i = 0; i < starts.length; i++) {
+        if (!values[i]) {
+            continue; // unknown, already `undefined`
+        }
+        const name = names[values[i] - 1];
+        const end = i + 1 < starts.length ? Math.min(starts[i + 1], length) : length;
+        result.fill(name, starts[i], end);
+    }
+    return result;
+}
 
 describe('categoryIntervals', () => {
     it('groups the trackpoints that share a value', () => {

website/src/lib/engine/trackpoint-categories.ts

@@ -11,31 +11,6 @@ export type CategoryIntervals = {
     names: string[];
 };
 
-/**
- * The value of each of the `length` trackpoints for a category of the engine, `undefined` when it
- * is unknown, or when the category is missing (it is unknown for every trackpoint). The intervals
- * are scanned once, so it takes a time linear in `length`.
- */
-export function categoryValues(
-    intervals: CategoryIntervals | undefined,
-    length: number
-): (string | undefined)[] {
-    const result: (string | undefined)[] = new Array(length).fill(undefined);
-    if (!intervals) {
-        return result;
-    }
-    const { starts, values, names } = intervals;
-    for (let i = 0; i < starts.length; i++) {
-        if (!values[i]) {
-            continue; // unknown, already `undefined`
-        }
-        const name = names[values[i] - 1];
-        const end = i + 1 < starts.length ? Math.min(starts[i + 1], length) : length;
-        result.fill(name, starts[i], end);
-    }
-    return result;
-}
-
 /** The index of the interval of `starts` (sorted) that the trackpoint `index` is in, -1 if none. */
 export function intervalAt(starts: Uint32Array, index: number): number {
     let low = 0;
@@ -66,7 +41,7 @@ export function categoryValue(
 
 /**
  * The intervals of the trackpoints that share a value, for a value per trackpoint (`undefined`
- * when unknown): the inverse of `categoryValues`. The names are in the order of their first
+ * when unknown). The names are in the order of their first
  * appearance. A value that is unknown everywhere gives no intervals.
  */
 export function categoryIntervals(values: readonly (string | undefined)[]): CategoryIntervals {

website/src/lib/engine/types.ts

@@ -9,7 +9,6 @@ export type { FileStatus, FolderEntry, UnsavedChoice, WorkspaceState } from './b
 export type {
     Clipboard,
     WaypointDetails,
-    TrackpointDetails,
     MoveTarget,
     GlobalStatistics,
     SelectionPoint,