refactoring and tests

website/src/lib/engine/file-state.ts

@@ -0,0 +1,101 @@
+import type { Feature, LineString } from 'geojson';
+import { normalizeColor, type FileColorAllocator } from '$lib/file-colors';
+import type { Visibility } from '$lib/file-visibility';
+import { toPositions, type Wasm } from './convert';
+import { EMPTY_STATISTICS, type FileState, type SegmentProperties } from './types';
+
+/** Reads the state of a file, reusing from `previous` what did not change. */
+export function readFileState(
+    wasm: Wasm,
+    id: string,
+    colors: FileColorAllocator,
+    visibility: ReadonlyMap<string, Visibility>,
+    previous?: FileState
+): FileState | null {
+    const structure = wasm.file_structure(id);
+    if (!structure) {
+        return null;
+    }
+
+    const color = colors.resolve(
+        id,
+        structure.tracks.map((track) => track.color)
+    );
+
+    const previousSegments = new Map(
+        previous?.segments.features.map((f) => [f.properties.segmentId, f]) ?? []
+    );
+    const segments: Feature<LineString, SegmentProperties>[] = [];
+    structure.tracks.forEach((track, trackIndex) => {
+        track.segments.forEach((segment, segmentIndex) => {
+            const properties: SegmentProperties = {
+                fileId: id,
+                trackId: track.id,
+                segmentId: segment.id,
+                trackIndex,
+                segmentIndex,
+                rev: segment.rev,
+                color: track.color !== undefined ? normalizeColor(track.color) : color,
+                opacity: track.opacity,
+                width: track.width,
+            };
+            const old = previousSegments.get(segment.id);
+            const unchanged =
+                old !== undefined &&
+                (Object.keys(properties) as (keyof SegmentProperties)[]).every(
+                    (key) => old.properties[key] === properties[key]
+                );
+            segments.push(
+                unchanged
+                    ? old
+                    : {
+                          type: 'Feature',
+                          geometry: {
+                              type: 'LineString',
+                              coordinates: toPositions(wasm.segment_coordinates(segment.id)),
+                          },
+                          properties,
+                      }
+            );
+        });
+    });
+
+    const previousStructure = previous?.structure;
+    const waypointsUnchanged =
+        previousStructure !== undefined &&
+        previousStructure.waypointsRev === structure.waypointsRev &&
+        previousStructure.waypoints.length === structure.waypoints.length &&
+        previousStructure.waypoints.every(
+            (w, i) =>
+                w.id === structure.waypoints[i].id &&
+                w.name === structure.waypoints[i].name &&
+                w.sym === structure.waypoints[i].sym
+        );
+    let waypoints = previous?.waypoints;
+    if (!waypoints || !waypointsUnchanged) {
+        const coordinates = toPositions(wasm.waypoint_coordinates(id));
+        waypoints = {
+            type: 'FeatureCollection',
+            features: structure.waypoints.map((waypoint, index) => ({
+                type: 'Feature',
+                geometry: { type: 'Point', coordinates: coordinates[index] },
+                properties: {
+                    fileId: id,
+                    waypointId: waypoint.id,
+                    index,
+                    name: waypoint.name,
+                    sym: waypoint.sym,
+                },
+            })),
+        };
+    }
+
+    return {
+        structure,
+        color,
+        statistics: wasm.file_statistics(id) ?? EMPTY_STATISTICS,
+        segments: { type: 'FeatureCollection', features: segments },
+        waypoints,
+        visibility: visibility.get(id) ?? new Map(),
+    };
+}