progress

gpx-rs/wasm/Cargo.toml

@@ -14,3 +14,6 @@ js-sys = "0.3.106"
 uuid = { version = "1.26.1", features = ["js"] }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4.79"
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3"

gpx-rs/wasm/src/command/edit.rs

@@ -0,0 +1,34 @@
+//! Editing the metadata, the style and the structure of the files.
+
+use gpx_engine::{self as engine, Command};
+use wasm_bindgen::prelude::*;
+
+use crate::ts::Outcome;
+
+use crate::session::*;
+
+// Edit commands
+
+#[wasm_bindgen]
+pub fn metadata(name: &str, desc: &str) -> Outcome {
+    edit(Command::Metadata(engine::Metadata { name, desc }))
+}
+
+#[wasm_bindgen]
+pub fn style(color: Option<String>, opacity: Option<f64>, width: Option<f64>) -> Outcome {
+    edit(Command::Style(engine::Style {
+        color: color.as_deref(),
+        opacity,
+        width,
+    }))
+}
+
+#[wasm_bindgen]
+pub fn new_track() -> Outcome {
+    edit(Command::NewTrack(engine::NewTrack))
+}
+
+#[wasm_bindgen]
+pub fn new_track_segment() -> Outcome {
+    edit(Command::NewTrackSegment(engine::NewTrackSegment))
+}

gpx-rs/wasm/src/command/files.rs

@@ -0,0 +1,120 @@
+//! Creating, loading, deleting, moving, copying and pasting files and their elements.
+
+use gpx_engine::{self as engine, Action, Command};
+use wasm_bindgen::prelude::*;
+
+use crate::convert::*;
+use crate::ids::*;
+use crate::session::*;
+use crate::ts::*;
+
+// File commands
+
+/// Creates a file and selects it. With `lng` and `lat`, it starts with a track and a segment that
+/// hold that trackpoint (at `ele`, 0 by default).
+#[wasm_bindgen]
+pub fn new_file(name: &str, lng: Option<f64>, lat: Option<f64>, ele: Option<f64>) -> Outcome {
+    let trackpoint = lng.zip(lat).map(|(lng, lat)| engine::NewTrackpoint {
+        lng,
+        lat,
+        ele: ele.unwrap_or_default(),
+    });
+    edit(Command::New(engine::New { name, trackpoint }))
+}
+
+/// Loads files as a single command (one undo step). The files are in `data`, one after the
+/// other, `lengths` being the number of bytes of each one. `names`: the name of each file when
+/// its data has none (the name on disk, without extension). The files that cannot be read are
+/// skipped, the first one that was read is selected.
+#[wasm_bindgen]
+pub fn load_files(data: &[u8], lengths: &[u32], names: Vec<String>) -> Outcome {
+    if lengths.len() != names.len() {
+        return fail(format!(
+            "{} lengths for {} names",
+            lengths.len(),
+            names.len()
+        ));
+    }
+    let mut files = Vec::with_capacity(names.len());
+    let mut offset = 0;
+    for (length, name) in lengths.iter().zip(&names) {
+        let end = offset + *length as usize;
+        let Some(data) = data.get(offset..end) else {
+            return fail(format!("the data of {name} is shorter than its length"));
+        };
+        files.push(engine::Load { data, name });
+        offset = end;
+    }
+    edit(Command::LoadFiles(engine::LoadFiles { files }))
+}
+
+#[wasm_bindgen]
+pub fn duplicate() -> Outcome {
+    edit(Command::Duplicate(engine::Duplicate))
+}
+
+/// Deletes the selected elements. With `whole_files`, the files holding the selected elements are
+/// deleted instead, even if only a track or a waypoint is selected.
+#[wasm_bindgen]
+pub fn delete(whole_files: bool) -> Outcome {
+    edit(Command::Delete(engine::Delete { whole_files }))
+}
+
+#[wasm_bindgen]
+pub fn delete_all() -> Outcome {
+    edit(Command::DeleteAll(engine::DeleteAll))
+}
+
+/// Moves the files to `index` among the other files, in the given order (not undoable).
+/// `file_ids_bytes`: concatenated 16-byte UUIDs.
+#[wasm_bindgen]
+pub fn reorder(file_ids_bytes: &[u8], index: usize) -> Outcome {
+    match file_ids(file_ids_bytes) {
+        Some(file_ids) => execute(Action::Reorder { file_ids, index }),
+        None => fail("the file ids are not a list of UUIDs"),
+    }
+}
+
+// Clipboard
+
+/// Puts the selected elements in the clipboard. Nothing happens when nothing is selected.
+#[wasm_bindgen]
+pub fn copy() -> Outcome {
+    execute(Action::Copy)
+}
+
+/// Like `copy`, but the elements are moved when they are pasted.
+#[wasm_bindgen]
+pub fn cut() -> Outcome {
+    execute(Action::Cut)
+}
+
+/// Pastes the clipboard according to the selection (see `can_paste`). What is pasted is always
+/// the elements as they were when they were copied or cut, even if they were changed or deleted
+/// since. It can be pasted several times: what was copied is copied again, what was cut is moved
+/// the first time (and the clipboard is not cut after that), then it is copied.
+#[wasm_bindgen]
+pub fn paste() -> Outcome {
+    edit(Command::Paste(engine::Paste))
+}
+
+/// Whether the clipboard can be pasted with the current selection.
+#[wasm_bindgen]
+pub fn can_paste() -> bool {
+    with_engine(|e| e.can_paste()).unwrap_or(false)
+}
+
+/// Moves elements (given as a `Selection`) to a place of the file tree, keeping their ids, like
+/// dragging and dropping them does. The moved elements are selected.
+///
+/// Files can only go among the files; tracks among the files (each becomes a file) or the tracks
+/// of a file; segments among the files (each becomes a file), the tracks of a file (each becomes
+/// a track) or the segments of a track; waypoints, or all the waypoints of a file, among the
+/// waypoints of a file.
+#[wasm_bindgen]
+pub fn move_elements(what: Selection, to: MoveTarget) -> Outcome {
+    match parse_selection(&what).zip(parse_move_target(&to)) {
+        Some((what, to)) => edit(Command::Move(engine::Move { what, to })),
+        None => fail("the elements or the target are not valid"),
+    }
+}

gpx-rs/wasm/src/command/history.rs

@@ -0,0 +1,30 @@
+//! Undo and redo.
+
+use gpx_engine::Action;
+use wasm_bindgen::prelude::*;
+
+use crate::ts::Outcome;
+
+use crate::session::*;
+
+// Undo-redo
+
+#[wasm_bindgen]
+pub fn undo() -> Outcome {
+    execute(Action::Undo)
+}
+
+#[wasm_bindgen]
+pub fn redo() -> Outcome {
+    execute(Action::Redo)
+}
+
+#[wasm_bindgen]
+pub fn can_undo() -> bool {
+    with_engine(|e| e.can_undo()).unwrap_or(false)
+}
+
+#[wasm_bindgen]
+pub fn can_redo() -> bool {
+    with_engine(|e| e.can_redo()).unwrap_or(false)
+}

gpx-rs/wasm/src/command/mod.rs

@@ -0,0 +1,6 @@
+pub(crate) mod edit;
+pub(crate) mod files;
+pub(crate) mod history;
+pub(crate) mod routing;
+pub(crate) mod tools;
+pub(crate) mod waypoints;

gpx-rs/wasm/src/command/routing.rs

@@ -0,0 +1,144 @@
+//! The commands that refer to trackpoints by their index in the routing buffers.
+
+use gpx_engine::{self as engine, Command};
+use js_sys::{Array, Uint8Array, Uint32Array};
+use wasm_bindgen::prelude::*;
+
+use crate::convert::*;
+use crate::ids::*;
+use crate::queries::routing::with_routing;
+use crate::session::*;
+use crate::ts::*;
+use crate::types::*;
+
+// Routing
+//
+// The indices of the trackpoints and of the anchors are the ones of the routing buffers: they only
+// mean something for the `revision` they were read with (`routing_revision`), and the commands
+// that use them do nothing if the selection is not the one of that revision anymore.
+
+/// Makes the call `f`, unless the selection is not the one of the revision anymore.
+pub(crate) fn at_revision(revision: u32, f: impl FnOnce() -> Outcome) -> Outcome {
+    if with_routing(|r| r.revision == revision).unwrap_or(false) {
+        f()
+    } else {
+        fail("the selection changed since the routing buffers were read")
+    }
+}
+
+/// A category of the trackpoints of a route: see `RouteCategory` in `engine`.
+pub(crate) struct ParsedCategory {
+    starts: Vec<u32>,
+    values: Vec<u8>,
+    names: Vec<String>,
+}
+
+impl ParsedCategory {
+    fn parse(attributes: &JsValue, key: &str) -> Option<Self> {
+        let Some(category) = property(attributes, key) else {
+            return Some(Self {
+                starts: vec![],
+                values: vec![],
+                names: vec![],
+            });
+        };
+        Some(Self {
+            starts: property(&category, "starts")?
+                .unchecked_into::<Uint32Array>()
+                .to_vec(),
+            values: property(&category, "values")?
+                .unchecked_into::<Uint8Array>()
+                .to_vec(),
+            names: Array::from(&property(&category, "names")?)
+                .iter()
+                .map(|name| name.as_string())
+                .collect::<Option<_>>()?,
+        })
+    }
+
+    fn view(&self) -> engine::RouteCategory<'_> {
+        engine::RouteCategory {
+            starts: &self.starts,
+            values: &self.values,
+            names: &self.names,
+        }
+    }
+}
+
+/// Replaces the trackpoints `start..end` of the selection by the given ones, in a single segment
+/// (see `RoutingBuffer`). A pure insertion if `start == end`, a pure removal without new points.
+/// `attributes` holds the surface, highway, SAC scale and MTB scale of the new points, as
+/// intervals, and `anchors` the indices among the new points of the ones that become anchors.
+/// Does nothing, and says why, if the revision of the routing buffers is not the given one.
+#[wasm_bindgen]
+#[allow(clippy::too_many_arguments)]
+pub fn route(
+    revision: u32,
+    start: u32,
+    end: u32,
+    lng: &[f64],
+    lat: &[f64],
+    ele: &[f64],
+    attributes: RouteAttributes,
+    anchors: &[u32],
+) -> Outcome {
+    let parse = |key| ParsedCategory::parse(&attributes, key);
+    let (Some(surface), Some(highway), Some(sac_scale), Some(mtb_scale)) = (
+        parse("surface"),
+        parse("highway"),
+        parse("sacScale"),
+        parse("mtbScale"),
+    ) else {
+        return fail("the attributes of the route are not valid");
+    };
+    if !same_len(lng, lat, ele) {
+        return fail("lng, lat and ele differ in length");
+    }
+    at_revision(revision, || {
+        edit(Command::Route(engine::Route {
+            start,
+            end,
+            lng,
+            lat,
+            ele,
+            surface: surface.view(),
+            highway: highway.view(),
+            sac_scale: sac_scale.view(),
+            mtb_scale: mtb_scale.view(),
+            anchors,
+        }))
+    })
+}
+
+/// Makes an anchor of the point of the selected segments that is the closest to the coordinates,
+/// inserting a trackpoint on the path if none is there. Does nothing, and says why, if the
+/// revision of the routing buffers is not the given one.
+#[wasm_bindgen]
+pub fn insert_anchor(revision: u32, lng: f64, lat: f64) -> Outcome {
+    at_revision(revision, || {
+        edit(Command::InsertAnchor(engine::InsertAnchor { lng, lat }))
+    })
+}
+
+/// Makes the trackpoint `index` of the selection the start of its segment, which is a loop (the
+/// trackpoints before it go to the end, and the loop closes on it). Does nothing, and says why, if the revision of the
+/// routing buffers is not the given one.
+#[wasm_bindgen]
+pub fn change_loop_start(revision: u32, index: u32) -> Outcome {
+    at_revision(revision, || {
+        edit(Command::ChangeLoopStart(engine::ChangeLoopStart { index }))
+    })
+}
+
+/// Cuts the file, the track or the segment (see `SplitType`) of the trackpoint `at` of the
+/// selection in two, there: the trackpoint ends the first part and starts the second one. Does
+/// nothing, and returns false, if the revision of the routing buffers is not the given one.
+#[wasm_bindgen]
+pub fn split(revision: u32, at: u32, split_type: SplitType) -> Outcome {
+    at_revision(revision, || {
+        edit(Command::Split(engine::Split {
+            at,
+            split_type: split_type.into(),
+        }))
+    })
+}

gpx-rs/wasm/src/command/tools.rs

@@ -0,0 +1,109 @@
+//! The tools: reversing, cropping, reducing, timestamps, merging, cleaning...
+
+use gpx_engine::{self as engine, Command, LngLat, LngLatBounds};
+use wasm_bindgen::prelude::*;
+
+use crate::ts::Outcome;
+
+use crate::session::*;
+use crate::types::*;
+
+// Tools
+
+#[wasm_bindgen]
+pub fn reverse() -> Outcome {
+    edit(Command::Reverse(engine::Reverse))
+}
+
+/// Adds to each selected segment a reversed copy of itself (without repeating its last point), so that it goes back to where it
+/// started.
+#[wasm_bindgen]
+pub fn round_trip() -> Outcome {
+    edit(Command::RoundTrip(engine::RoundTrip))
+}
+
+/// Keeps the trackpoints `start` to `end` (both included) of the selection, counted over its
+/// segments one after the other, and removes the others (and what is left empty).
+#[wasm_bindgen]
+pub fn crop(start: u32, end: u32) -> Outcome {
+    if start > end {
+        return fail(format!("the range {start}..{end} is reversed"));
+    }
+    edit(Command::Crop(engine::Crop { start, end }))
+}
+
+/// Removes the trackpoints of the selection that are less than `tolerance` meters away from the
+/// line of their neighbours, except the ends of the segments.
+#[wasm_bindgen]
+pub fn reduce(tolerance: f64) -> Outcome {
+    edit(Command::Reduce(engine::Reduce { tolerance }))
+}
+
+/// Sets the timestamps of the selection, which starts at `start_time` (ms since the epoch): the
+/// trackpoints that have some keep their durations multiplied by `ratio`, the others follow the
+/// previous one at `speed` (km/h).
+#[wasm_bindgen(js_name = changeTimestamps)]
+pub fn change_timestamps(start_time: f64, speed: f64, ratio: f64) -> Outcome {
+    edit(Command::Time(engine::Time {
+        start_time: start_time as i64,
+        kind: engine::TimeKind::Change { speed, ratio },
+    }))
+}
+
+/// Makes up timestamps for the selection, which starts at `start_time` (ms since the epoch) and
+/// lasts `total_time` seconds.
+#[wasm_bindgen(js_name = createArtificialTimestamps)]
+pub fn create_artificial_timestamps(start_time: f64, total_time: f64) -> Outcome {
+    edit(Command::Time(engine::Time {
+        start_time: start_time as i64,
+        kind: engine::TimeKind::Artificial { total_time },
+    }))
+}
+
+/// Merges the selection into its first element (see `MergeType`). `remove_gaps` brings the parts
+/// that are connected closer in time, if they have timestamps.
+#[wasm_bindgen]
+pub fn merge(type_: MergeType, remove_gaps: bool) -> Outcome {
+    edit(Command::Merge(engine::Merge {
+        type_: type_.into(),
+        remove_gaps,
+    }))
+}
+
+#[wasm_bindgen]
+pub fn extract() -> Outcome {
+    edit(Command::Extract(engine::Extract))
+}
+
+/// Sets the elevation of the trackpoints of the selection, one elevation per trackpoint.
+#[wasm_bindgen]
+pub fn elevation(ele: &[f64]) -> Outcome {
+    edit(Command::Elevation(engine::Elevation { ele }))
+}
+
+#[wasm_bindgen]
+pub fn clean(
+    west: f64,
+    south: f64,
+    east: f64,
+    north: f64,
+    type_: CleanType,
+    trkpt: bool,
+    wpt: bool,
+) -> Outcome {
+    edit(Command::Clean(engine::Clean {
+        bounds: LngLatBounds {
+            sw: LngLat {
+                lng: west,
+                lat: south,
+            },
+            ne: LngLat {
+                lng: east,
+                lat: north,
+            },
+        },
+        type_: type_.into(),
+        trkpt,
+        wpt,
+    }))
+}

gpx-rs/wasm/src/command/waypoints.rs

@@ -0,0 +1,90 @@
+//! Creating, editing, moving and deleting waypoints.
+
+use gpx_engine::{self as engine, Command};
+use wasm_bindgen::prelude::*;
+
+use crate::ts::Outcome;
+
+use crate::ids::*;
+use crate::session::*;
+
+#[wasm_bindgen]
+pub fn new_waypoint(
+    lng: f64,
+    lat: f64,
+    ele: f64,
+    name: &str,
+    desc: &str,
+    icon: &str,
+    link: &str,
+) -> Outcome {
+    edit(Command::NewWaypoint(engine::NewWaypoint {
+        lng,
+        lat,
+        ele,
+        name,
+        desc,
+        icon,
+        link,
+    }))
+}
+
+/// Moves a waypoint of a file, whatever is selected.
+#[wasm_bindgen]
+pub fn move_waypoint(file_id: &str, waypoint_id: &str, lng: f64, lat: f64, ele: f64) -> Outcome {
+    match (parse_file_id(file_id), parse_waypoint_id(waypoint_id)) {
+        (Some(file_id), Some(waypoint_id)) => edit(Command::MoveWaypoint(engine::MoveWaypoint {
+            file_id,
+            waypoint_id,
+            lng,
+            lat,
+            ele,
+        })),
+        _ => fail("the file or waypoint id is not a UUID"),
+    }
+}
+
+/// Deletes a waypoint of a file, whatever is selected.
+#[wasm_bindgen]
+pub fn delete_waypoint(file_id: &str, waypoint_id: &str) -> Outcome {
+    match (parse_file_id(file_id), parse_waypoint_id(waypoint_id)) {
+        (Some(file_id), Some(waypoint_id)) => {
+            edit(Command::DeleteWaypoint(engine::DeleteWaypoint {
+                file_id,
+                waypoint_id,
+            }))
+        }
+        _ => fail("the file or waypoint id is not a UUID"),
+    }
+}
+
+/// Changes a waypoint of a file, whatever is selected: its name, description, icon, link, position
+/// and elevation. The strings that are empty remove the field.
+#[wasm_bindgen]
+#[allow(clippy::too_many_arguments)]
+pub fn update_waypoint(
+    file_id: &str,
+    waypoint_id: &str,
+    lng: f64,
+    lat: f64,
+    ele: f64,
+    name: &str,
+    desc: &str,
+    icon: &str,
+    link: &str,
+) -> Outcome {
+    match (parse_file_id(file_id), parse_waypoint_id(waypoint_id)) {
+        (Some(file_id), Some(waypoint_id)) => edit(Command::EditWaypoint(engine::EditWaypoint {
+            file_id,
+            waypoint_id,
+            lng,
+            lat,
+            ele,
+            name,
+            desc,
+            icon,
+            link,
+        })),
+        _ => fail("the file or waypoint id is not a UUID"),
+    }
+}

gpx-rs/wasm/src/convert.rs

@@ -0,0 +1,266 @@
+//! Turning engine types into JS objects and back.
+
+use gpx_engine::{self as engine, FileId};
+use js_sys::{Array, Object, Reflect};
+use wasm_bindgen::prelude::*;
+
+use crate::ts::*;
+
+pub(crate) fn property(object: &JsValue, key: &str) -> Option<JsValue> {
+    Reflect::get(object, &key.into())
+        .ok()
+        .filter(|value| !value.is_undefined())
+}
+
+pub(crate) fn uuid_property(object: &JsValue, key: &str) -> Option<uuid::Uuid> {
+    uuid::Uuid::parse_str(&property(object, key)?.as_string()?).ok()
+}
+
+pub(crate) fn uuids_property(object: &JsValue, key: &str) -> Option<Vec<uuid::Uuid>> {
+    Array::from(&property(object, key)?)
+        .iter()
+        .map(|id| uuid::Uuid::parse_str(&id.as_string()?).ok())
+        .collect()
+}
+
+/// The inverse of `selection_object`.
+pub(crate) fn parse_selection(value: &JsValue) -> Option<engine::Selection> {
+    use engine::Selection as S;
+    let file_id = || uuid_property(value, "fileId").map(FileId);
+    Some(match property(value, "type")?.as_string()?.as_str() {
+        "empty" => S::Empty,
+        "file" => S::File {
+            file_ids: uuids_property(value, "fileIds")?
+                .into_iter()
+                .map(FileId)
+                .collect(),
+        },
+        "track" => S::Track {
+            file_id: file_id()?,
+            trk_ids: uuids_property(value, "trackIds")?
+                .into_iter()
+                .map(engine::TrackId)
+                .collect(),
+        },
+        "segment" => S::TrackSegment {
+            file_id: file_id()?,
+            trk_id: engine::TrackId(uuid_property(value, "trackId")?),
+            trkseg_ids: uuids_property(value, "segmentIds")?
+                .into_iter()
+                .map(engine::TrackSegmentId)
+                .collect(),
+        },
+        "waypoints" => S::Waypoints {
+            file_id: file_id()?,
+        },
+        "waypoint" => S::Waypoint {
+            file_id: file_id()?,
+            wpt_ids: uuids_property(value, "waypointIds")?
+                .into_iter()
+                .map(engine::WaypointId)
+                .collect(),
+        },
+        _ => return None,
+    })
+}
+
+pub(crate) fn parse_move_target(value: &JsValue) -> Option<engine::MoveTarget> {
+    use engine::MoveTarget as T;
+    // a negative index is the start, an infinite one is the end
+    let index = property(value, "index")?.as_f64()?.max(0.0) as usize;
+    let file_id = || uuid_property(value, "fileId").map(FileId);
+    Some(match property(value, "type")?.as_string()?.as_str() {
+        "files" => T::Files { index },
+        "tracks" => T::Tracks {
+            file_id: file_id()?,
+            index,
+        },
+        "segments" => T::Segments {
+            file_id: file_id()?,
+            trk_id: engine::TrackId(uuid_property(value, "trackId")?),
+            index,
+        },
+        "waypoints" => T::Waypoints {
+            file_id: file_id()?,
+            index,
+        },
+        _ => return None,
+    })
+}
+
+pub(crate) fn set(object: &Object, key: &str, value: impl Into<JsValue>) {
+    Reflect::set(object, &key.into(), &value.into()).unwrap();
+}
+
+pub(crate) fn array<T>(items: &[T], f: impl Fn(&T) -> JsValue) -> Array {
+    items.iter().map(f).collect()
+}
+
+pub(crate) fn ids(items: &[FileId]) -> Array {
+    array(items, |id| id.0.to_string().into())
+}
+
+pub(crate) fn named_node(id: uuid::Uuid, name: Option<&str>) -> Object {
+    let node = Object::new();
+    set(&node, "id", id.to_string());
+    if let Some(name) = name {
+        set(&node, "name", name);
+    }
+    node
+}
+
+pub(crate) fn structure_object(file: &engine::FileStructure) -> Object {
+    let node = named_node(file.id.0, Some(&file.name));
+    if let Some(desc) = &file.desc {
+        set(&node, "desc", desc.as_str());
+    }
+    set(
+        &node,
+        "tracks",
+        array(&file.tracks, |trk| {
+            let node = named_node(trk.id.0, trk.name.as_deref());
+            if let Some(desc) = &trk.desc {
+                set(&node, "desc", desc.as_str());
+            }
+            if let Some(color) = &trk.color {
+                set(&node, "color", color.as_str());
+            }
+            if let Some(opacity) = trk.opacity {
+                set(&node, "opacity", opacity);
+            }
+            if let Some(width) = trk.width {
+                set(&node, "width", width);
+            }
+            set(
+                &node,
+                "segments",
+                array(&trk.segments, |seg| {
+                    let node = named_node(seg.id.0, None);
+                    set(&node, "rev", seg.rev_id.0.to_string());
+                    set(&node, "length", seg.len as f64);
+                    node.into()
+                }),
+            );
+            node.into()
+        }),
+    );
+    set(
+        &node,
+        "waypoints",
+        array(&file.waypoints, |wpt| {
+            let node = named_node(wpt.id.0, wpt.name.as_deref());
+            if let Some(sym) = &wpt.sym {
+                set(&node, "sym", sym.as_str());
+            }
+            node.into()
+        }),
+    );
+    set(&node, "waypointsRev", file.wpt_rev_id.0.to_string());
+    node
+}
+
+pub(crate) fn statistics_object(stats: &engine::GlobalStatistics) -> GlobalStatistics {
+    let object = Object::new();
+    let optional = |key: &str, value: Option<f64>| {
+        if let Some(value) = value {
+            set(&object, key, value);
+        }
+    };
+    let seconds = |ms: Option<i64>| ms.map(|ms| ms as f64 / 1000.0);
+    let average = |key: &str, average: &engine::Average| {
+        if let Some(avg) = average.avg() {
+            let value = Object::new();
+            set(&value, "avg", avg);
+            set(&value, "count", f64::from(average.count));
+            set(&object, key, value);
+        }
+    };
+    set(&object, "totalDistance", stats.total_distance);
+    optional("movingDistance", stats.moving_distance);
+    optional("totalTime", seconds(stats.total_time));
+    optional("movingTime", seconds(stats.moving_time));
+    set(&object, "elevationGain", stats.elevation_gain);
+    set(&object, "elevationLoss", stats.elevation_loss);
+    optional("startTime", stats.start_time.map(|t| t as f64));
+    optional("endTime", stats.end_time.map(|t| t as f64));
+    optional("totalSpeed", stats.total_speed());
+    optional("movingSpeed", stats.moving_speed());
+    average("hr", &stats.hr);
+    average("cad", &stats.cad);
+    average("atemp", &stats.atemp);
+    average("power", &stats.power);
+    let (sw, ne) = (&stats.bounds.sw, &stats.bounds.ne);
+    if sw.lng <= ne.lng && sw.lat <= ne.lat {
+        let bounds = Object::new();
+        set(&bounds, "west", sw.lng);
+        set(&bounds, "south", sw.lat);
+        set(&bounds, "east", ne.lng);
+        set(&bounds, "north", ne.lat);
+        set(&object, "bounds", bounds);
+    }
+    object.unchecked_into()
+}
+
+pub(crate) fn uuids<T>(
+    items: impl IntoIterator<Item = T>,
+    uuid: impl Fn(T) -> uuid::Uuid,
+) -> Array {
+    items
+        .into_iter()
+        .map(|item| JsValue::from(uuid(item).to_string()))
+        .collect()
+}
+
+pub(crate) fn selection_object(selection: &engine::Selection) -> Object {
+    use engine::Selection as S;
+    let object = Object::new();
+    match selection {
+        S::Empty => set(&object, "type", "empty"),
+        S::File { file_ids } => {
+            set(&object, "type", "file");
+            set(&object, "fileIds", uuids(file_ids, |id| id.0));
+        }
+        S::Track { file_id, trk_ids } => {
+            set(&object, "type", "track");
+            set(&object, "fileId", file_id.0.to_string());
+            set(&object, "trackIds", uuids(trk_ids, |id| id.0));
+        }
+        S::TrackSegment {
+            file_id,
+            trk_id,
+            trkseg_ids,
+        } => {
+            set(&object, "type", "segment");
+            set(&object, "fileId", file_id.0.to_string());
+            set(&object, "trackId", trk_id.0.to_string());
+            set(&object, "segmentIds", uuids(trkseg_ids, |id| id.0));
+        }
+        S::Waypoints { file_id } => {
+            set(&object, "type", "waypoints");
+            set(&object, "fileId", file_id.0.to_string());
+        }
+        S::Waypoint { file_id, wpt_ids } => {
+            set(&object, "type", "waypoint");
+            set(&object, "fileId", file_id.0.to_string());
+            set(&object, "waypointIds", uuids(wpt_ids, |id| id.0));
+        }
+    }
+    object
+}
+
+/// The outcome of a call. `error` is what it says about why nothing was done, if that is so.
+pub(crate) fn outcome_object(outcome: &engine::Outcome, error: Option<&str>) -> Outcome {
+    let object = Object::new();
+    let diff = outcome.diff.clone().unwrap_or_default();
+    set(&object, "changed", outcome.changed);
+    set(&object, "orderChanged", outcome.order_changed);
+    set(&object, "selectionChanged", outcome.selection_changed);
+    set(&object, "clipboardChanged", outcome.clipboard_changed);
+    set(&object, "added", ids(&diff.added));
+    set(&object, "modified", ids(&diff.modified));
+    set(&object, "removed", ids(&diff.removed));
+    if let Some(error) = error {
+        set(&object, "error", error);
+    }
+    object.unchecked_into()
+}

gpx-rs/wasm/src/idb.rs

@@ -4,7 +4,7 @@
 //! store per kind of data. A batch is a single transaction, so that the stored files always are
 //! ones that the engine had.
 
-use gpx_engine::{Batch, FileId, Storage, StorageError, StoredData};
+use gpx_engine::{Batch, ChunkKey, ChunkKind, FileId, Storage, StorageError, StoredData};
 use idb::TransactionMode;
 use idb::{Database, DatabaseEvent, Factory, ObjectStore, ObjectStoreParams, Query, Transaction};
 use js_sys::Uint8Array;
@@ -30,6 +30,14 @@ fn error(error: impl std::fmt::Display) -> StorageError {
     StorageError(error.to_string())
 }
 
+/// The object store of a kind of chunks.
+fn chunk_store(kind: ChunkKind) -> &'static str {
+    match kind {
+        ChunkKind::Trackpoints => TRACKPOINT_CHUNKS,
+        ChunkKind::Waypoints => WAYPOINT_CHUNKS,
+    }
+}
+
 fn key(id: Uuid) -> JsValue {
     JsValue::from_str(&id.to_string())
 }
@@ -82,20 +90,16 @@ impl IdbStorage {
 
     async fn write(&self, transaction: &Transaction, batch: &Batch) -> Result<(), StorageError> {
         let files = transaction.object_store(FILES).map_err(error)?;
-        let trackpoints = transaction.object_store(TRACKPOINT_CHUNKS).map_err(error)?;
-        let waypoints = transaction.object_store(WAYPOINT_CHUNKS).map_err(error)?;
         let meta = transaction.object_store(META).map_err(error)?;
 
         // the requests are all made before waiting for them
         let mut puts = vec![];
         let mut deletes = vec![];
-        for (store, chunks) in [
-            (&trackpoints, &batch.put_trackpoint_chunks),
-            (&waypoints, &batch.put_waypoint_chunks),
-        ] {
-            for (id, data) in chunks {
-                puts.push(store.put(&bytes(data), Some(&key(*id))).map_err(error)?);
-            }
+        for (ChunkKey { kind, id }, data) in &batch.put_chunks {
+            let store = transaction
+                .object_store(chunk_store(*kind))
+                .map_err(error)?;
+            puts.push(store.put(&bytes(data), Some(&key(*id))).map_err(error)?);
         }
         for (FileId(id), data) in &batch.put_files {
             puts.push(files.put(&bytes(data), Some(&key(*id))).map_err(error)?);
@@ -117,13 +121,11 @@ impl IdbStorage {
         for FileId(id) in &batch.delete_files {
             deletes.push(files.delete(Query::Key(key(*id))).map_err(error)?);
         }
-        for (store, ids) in [
-            (&trackpoints, &batch.delete_trackpoint_chunks),
-            (&waypoints, &batch.delete_waypoint_chunks),
-        ] {
-            for id in ids {
-                deletes.push(store.delete(Query::Key(key(*id))).map_err(error)?);
-            }
+        for ChunkKey { kind, id } in &batch.delete_chunks {
+            let store = transaction
+                .object_store(chunk_store(*kind))
+                .map_err(error)?;
+            deletes.push(store.delete(Query::Key(key(*id))).map_err(error)?);
         }
         for put in puts {
             put.await.map_err(error)?;
@@ -169,8 +171,15 @@ impl Storage for IdbStorage {
                 .into_iter()
                 .map(|(id, data)| (FileId(id), data))
                 .collect(),
-            trackpoint_chunks: ids(trackpoint_chunks)?,
-            waypoint_chunks: ids(waypoint_chunks)?,
+            chunks: ids(trackpoint_chunks)?
+                .into_iter()
+                .map(|(id, data)| (ChunkKey::trackpoints(id), data))
+                .chain(
+                    ids(waypoint_chunks)?
+                        .into_iter()
+                        .map(|(id, data)| (ChunkKey::waypoints(id), data)),
+                )
+                .collect(),
             order: order.as_ref().map(to_vec),
             categories: categories.as_ref().map(to_vec),
         })

gpx-rs/wasm/src/ids.rs

@@ -0,0 +1,25 @@
+//! Ids, which cross as strings (one id) or as concatenated 16-byte UUIDs (several).
+
+use gpx_engine::{self as engine, FileId};
+
+pub(crate) fn uuid_list(bytes: &[u8]) -> Option<Vec<uuid::Uuid>> {
+    let (chunks, rest) = bytes.as_chunks::<16>();
+    rest.is_empty()
+        .then(|| chunks.iter().map(|c| uuid::Uuid::from_bytes(*c)).collect())
+}
+
+pub(crate) fn file_ids(bytes: &[u8]) -> Option<Vec<FileId>> {
+    uuid_list(bytes).map(|ids| ids.into_iter().map(FileId).collect())
+}
+
+pub(crate) fn parse_file_id(id: &str) -> Option<FileId> {
+    uuid::Uuid::parse_str(id).ok().map(FileId)
+}
+
+pub(crate) fn same_len(a: &[f64], b: &[f64], c: &[f64]) -> bool {
+    a.len() == b.len() && b.len() == c.len()
+}
+
+pub(crate) fn parse_waypoint_id(id: &str) -> Option<engine::WaypointId> {
+    uuid::Uuid::parse_str(id).ok().map(engine::WaypointId)
+}

gpx-rs/wasm/src/persistence.rs

@@ -0,0 +1,143 @@
+//! Keeping the files and the settings in the browser.
+
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+use gpx_engine::{self as engine, Engine, Persister, Storage};
+use js_sys::Object;
+use wasm_bindgen::prelude::*;
+
+use crate::convert::{outcome_object, set};
+use crate::idb::IdbStorage;
+use crate::session::*;
+use crate::ts::StorageOpened;
+
+// Storage
+//
+// The files are saved in IndexedDB after each change that touches them, without making the change
+// wait: `schedule_save` starts a loop that writes what changed since the last write, until
+// nothing has. The settings are opaque to the engine, the frontend keeps its own copy of them.
+
+thread_local! {
+    static STORAGE: RefCell<Option<Rc<IdbStorage>>> = const { RefCell::new(None) };
+    static PERSISTER: RefCell<Option<Persister>> = const { RefCell::new(None) };
+    static SAVING: Cell<bool> = const { Cell::new(false) };
+    static DIRTY: Cell<bool> = const { Cell::new(false) };
+    /// Resolve functions of the promises of `flush_storage`.
+    static WAITERS: RefCell<Vec<js_sys::Function>> = const { RefCell::new(Vec::new()) };
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = console, js_name = error)]
+    fn console_error(message: &str);
+}
+
+pub(crate) fn storage() -> Option<Rc<IdbStorage>> {
+    STORAGE.with(|storage| storage.borrow().clone())
+}
+
+pub(crate) fn schedule_save() {
+    if storage().is_none() {
+        return;
+    }
+    DIRTY.set(true);
+    if SAVING.replace(true) {
+        // the running loop will go around again
+        return;
+    }
+    wasm_bindgen_futures::spawn_local(async {
+        while DIRTY.replace(false) {
+            let Some(storage) = storage() else { break };
+            let Some(snapshot) = with_engine(Engine::snapshot) else {
+                break;
+            };
+            let mut persister = PERSISTER
+                .with(|persister| persister.borrow_mut().take())
+                .unwrap_or_default();
+            let result = persister.save(&*storage, snapshot).await;
+            PERSISTER.with(|slot| *slot.borrow_mut() = Some(persister));
+            if let Err(error) = result {
+                // what failed is written with the next change
+                console_error(&error.to_string());
+            }
+        }
+        SAVING.set(false);
+        for resolve in WAITERS.with(|waiters| std::mem::take(&mut *waiters.borrow_mut())) {
+            let _ = resolve.call0(&JsValue::UNDEFINED);
+        }
+    });
+}
+
+/// Opens the database `name` (it is created if it does not exist), puts the files that it holds
+/// in the engine, which has to be empty, and returns the settings (JSON strings by key) and the
+/// outcome of putting the files in. The changes of the files that follow are saved, unless some of
+/// what is stored was written by a newer version of the app (`readOnly`): then nothing is, so that
+/// the newer version finds its data again.
+#[wasm_bindgen]
+pub async fn open_storage(name: &str) -> Result<StorageOpened, JsValue> {
+    let empty = with_engine(|e| e.snapshot().files.is_empty()).unwrap_or(false);
+    if !empty {
+        return Err(JsValue::from_str("the engine already has files"));
+    }
+    let storage = IdbStorage::open(name).await.map_err(to_js_error)?;
+    let mut persister = Persister::default();
+    let restored = persister.restore(&storage).await.map_err(to_js_error)?;
+    let (read_only, unreadable) = (restored.read_only, restored.unreadable);
+    let settings = storage.load_settings().await.map_err(to_js_error)?;
+
+    let outcome = with_engine_mut(|engine| engine.restore(restored)).unwrap_or_default();
+    PERSISTER.with(|slot| *slot.borrow_mut() = Some(persister));
+    STORAGE.with(|slot| *slot.borrow_mut() = Some(Rc::new(storage)));
+
+    let settings_object = Object::new();
+    for (key, value) in settings {
+        set(&settings_object, &key, value);
+    }
+    let opened = Object::new();
+    set(&opened, "settings", settings_object);
+    set(&opened, "outcome", outcome_object(&outcome, None));
+    set(&opened, "readOnly", read_only);
+    set(&opened, "unreadable", unreadable as f64);
+    Ok(opened.unchecked_into())
+}
+
+pub(crate) fn to_js_error(error: engine::StorageError) -> JsValue {
+    JsValue::from_str(&error.to_string())
+}
+
+/// Resolves when what was changed has been written to the storage.
+#[wasm_bindgen]
+pub async fn flush_storage() -> Result<(), JsValue> {
+    if !SAVING.get() {
+        return Ok(());
+    }
+    let promise = js_sys::Promise::new(&mut |resolve, _| {
+        WAITERS.with(|waiters| waiters.borrow_mut().push(resolve));
+    });
+    wasm_bindgen_futures::JsFuture::from(promise).await?;
+    Ok(())
+}
+
+/// Saves a setting, `value` being its JSON.
+#[wasm_bindgen]
+pub fn set_setting(key: String, value: String) {
+    if let Some(storage) = storage() {
+        wasm_bindgen_futures::spawn_local(async move {
+            if let Err(error) = storage.put_setting(&key, &value).await {
+                console_error(&error.to_string());
+            }
+        });
+    }
+}
+
+#[wasm_bindgen]
+pub fn delete_setting(key: String) {
+    if let Some(storage) = storage() {
+        wasm_bindgen_futures::spawn_local(async move {
+            if let Err(error) = storage.delete_setting(&key).await {
+                console_error(&error.to_string());
+            }
+        });
+    }
+}

gpx-rs/wasm/src/queries/coordinates.rs

@@ -0,0 +1,37 @@
+//! The coordinates of the trackpoints and waypoints, as flat typed arrays.
+
+use gpx_engine::{self as engine, Engine, FileId};
+use js_sys::Float64Array;
+use wasm_bindgen::prelude::*;
+
+use crate::session::*;
+
+// Coordinates buffers
+//
+// Like the statistics buffers, these are copies. They are flat `[lng, lat, ...]` arrays. Compare `rev` / `waypointsRev` of the file structures with the previous ones to know which
+// buffers actually changed.
+
+pub(crate) fn coordinates_array(f: impl FnOnce(&Engine) -> Option<&[f64]>) -> Float64Array {
+    ENGINE.with(|engine| match engine.borrow().as_ref().and_then(f) {
+        Some(coordinates) => Float64Array::from(coordinates),
+        None => Float64Array::new_with_length(0),
+    })
+}
+
+/// Coordinates of the trackpoints of a segment (empty if the id is unknown).
+#[wasm_bindgen]
+pub fn segment_coordinates(segment_id: &str) -> Float64Array {
+    match uuid::Uuid::parse_str(segment_id) {
+        Ok(id) => coordinates_array(|e| Some(e.segment_coordinates(&engine::TrackSegmentId(id)))),
+        Err(_) => Float64Array::new_with_length(0),
+    }
+}
+
+/// Coordinates of the waypoints of a file (empty if the id is unknown).
+#[wasm_bindgen]
+pub fn waypoint_coordinates(file_id: &str) -> Float64Array {
+    match uuid::Uuid::parse_str(file_id) {
+        Ok(id) => coordinates_array(|e| Some(e.waypoint_coordinates(&FileId(id)))),
+        Err(_) => Float64Array::new_with_length(0),
+    }
+}

gpx-rs/wasm/src/queries/files.rs

@@ -0,0 +1,209 @@
+//! The files, their structure and statistics, the selection and the clipboard.
+
+// File order and structures
+//
+// The files are described by one ordered list of ids and one structure object per file, so that
+// the UI can react to what changed only: after each action, `last_update` tells which
+// structures to (re)read or drop and whether the order changed. Ids are UUID strings. The
+// trackpoints of a segment and the waypoints of a file are in the same order as the coordinates
+// of their buffers (see below).
+
+use gpx_engine::{self as engine, FileId};
+use js_sys::Object;
+use wasm_bindgen::prelude::*;
+
+use crate::convert::*;
+use crate::ids::*;
+use crate::queries::statistics::with_stats;
+use crate::session::*;
+use crate::ts::*;
+
+/// Ids of the files in display order.
+#[wasm_bindgen]
+pub fn file_order() -> FileOrder {
+    let order = with_engine(|e| ids(e.order())).unwrap_or_default();
+    order.unchecked_into()
+}
+
+/// Structure of a file, `undefined` if the id is unknown.
+#[wasm_bindgen]
+pub fn file_structure(file_id: &str) -> FileStructure {
+    let structure = uuid::Uuid::parse_str(file_id)
+        .ok()
+        .and_then(|id| {
+            with_engine(|e| e.file_structure(&FileId(id)).map(structure_object)).flatten()
+        })
+        .map_or(JsValue::UNDEFINED, JsValue::from);
+    structure.unchecked_into()
+}
+
+/// Global statistics of a file, `undefined` if the id is unknown.
+#[wasm_bindgen]
+pub fn file_statistics(file_id: &str) -> GlobalStatistics {
+    uuid::Uuid::parse_str(file_id)
+        .ok()
+        .and_then(|id| with_engine(|e| e.file_statistics(&FileId(id))).flatten())
+        .map_or(JsValue::UNDEFINED.unchecked_into(), |stats| {
+            statistics_object(&stats)
+        })
+}
+
+/// Global statistics of the whole selection (the arrays of the statistics buffers cover it).
+#[wasm_bindgen]
+pub fn selection_statistics() -> GlobalStatistics {
+    with_stats(|buffer| statistics_object(&buffer.global))
+        .unwrap_or_else(|| JsValue::UNDEFINED.unchecked_into())
+}
+
+/// A file as GPX (UTF-8 bytes), `undefined` if it does not exist. The options say which data of the trackpoints
+/// to keep.
+#[wasm_bindgen]
+pub fn export_file(
+    file_id: &str,
+    time: bool,
+    hr: bool,
+    cad: bool,
+    atemp: bool,
+    power: bool,
+    osm: bool,
+) -> Option<Vec<u8>> {
+    let id = parse_file_id(file_id)?;
+    let options = engine::ExportOptions {
+        time,
+        hr,
+        cad,
+        atemp,
+        power,
+        osm,
+    };
+    with_engine(|e| e.export(&id, options)).flatten()
+}
+
+/// The data that some files have, so that the ones that none has are not offered when exporting
+/// them: a bit for the time (1), heart rate (2), cadence (4), temperature (8), power (16) and the
+/// OpenStreetMap data (32). `file_ids` are concatenated UUIDs.
+#[wasm_bindgen]
+pub fn exportable_data(file_ids: &[u8]) -> u8 {
+    let Some(ids) = self::file_ids(file_ids) else {
+        return 0;
+    };
+    let data = with_engine(|e| e.exportable_data(&ids)).unwrap_or(engine::ExportOptions::NONE);
+    [
+        data.time, data.hr, data.cad, data.atemp, data.power, data.osm,
+    ]
+    .iter()
+    .enumerate()
+    .fold(0, |bits, (i, on)| bits | (u8::from(*on) << i))
+}
+
+/// Global statistics of the trackpoints from `start` to `end` (both included) of the selection,
+/// as indexed by the statistics buffers. `undefined` when the range is not in the selection.
+#[wasm_bindgen]
+pub fn slice_statistics(start: usize, end: usize) -> GlobalStatistics {
+    with_stats(|buffer| buffer.slice(start, end))
+        .flatten()
+        .map_or(JsValue::UNDEFINED.unchecked_into(), |stats| {
+            statistics_object(&stats)
+        })
+}
+
+/// The current selection (ids are UUID strings).
+#[wasm_bindgen]
+pub fn selection() -> Selection {
+    with_engine(|e| selection_object(e.selection()))
+        .unwrap_or_default()
+        .unchecked_into()
+}
+
+/// All the data of a waypoint of a file, `undefined` if it does not exist.
+#[wasm_bindgen]
+pub fn waypoint(file_id: &str, waypoint_id: &str) -> WaypointDetails {
+    uuid::Uuid::parse_str(file_id)
+        .ok()
+        .zip(uuid::Uuid::parse_str(waypoint_id).ok())
+        .and_then(|(file_id, id)| {
+            with_engine(|e| {
+                e.waypoint(&FileId(file_id), &engine::WaypointId(id))
+                    .map(|wpt| {
+                        let object = Object::new();
+                        set(&object, "id", wpt.id.0.to_string());
+                        set(&object, "lng", wpt.coordinates.lng);
+                        set(&object, "lat", wpt.coordinates.lat);
+                        set(&object, "ele", wpt.ele);
+                        if let Some(time) = wpt.time {
+                            set(&object, "time", time as f64);
+                        }
+                        for (key, value) in [
+                            ("name", &wpt.name),
+                            ("desc", &wpt.desc),
+                            ("cmt", &wpt.cmt),
+                            ("sym", &wpt.sym),
+                        ] {
+                            if let Some(value) = value {
+                                set(&object, key, value.as_str());
+                            }
+                        }
+                        if let Some(link) = &wpt.link {
+                            let link_object = Object::new();
+                            set(&link_object, "href", link.href.as_str());
+                            if let Some(text) = &link.text {
+                                set(&link_object, "text", text.as_str());
+                            }
+                            set(&object, "link", link_object);
+                        }
+                        JsValue::from(object)
+                    })
+            })
+            .flatten()
+        })
+        .unwrap_or(JsValue::UNDEFINED)
+        .unchecked_into()
+}
+
+/// A trackpoint of a segment of a file, `undefined` if it does not exist.
+#[wasm_bindgen]
+pub fn trackpoint(file_id: &str, segment_id: &str, index: usize) -> TrackpointDetails {
+    parse_file_id(file_id)
+        .zip(uuid::Uuid::parse_str(segment_id).ok())
+        .and_then(|(file_id, segment_id)| {
+            with_engine(|e| {
+                e.trackpoint(&file_id, &engine::TrackSegmentId(segment_id), index)
+                    .map(|pt| {
+                        let object = Object::new();
+                        set(&object, "lng", pt.coordinates.lng);
+                        set(&object, "lat", pt.coordinates.lat);
+                        set(&object, "ele", pt.ele);
+                        if let Some(time) = pt.time {
+                            set(&object, "time", time as f64);
+                        }
+                        JsValue::from(object)
+                    })
+            })
+            .flatten()
+        })
+        .unwrap_or(JsValue::UNDEFINED)
+        .unchecked_into()
+}
+
+/// What was copied or cut and is waiting to be pasted, `undefined` if nothing: the kind of the
+/// elements and their ids (UUID strings).
+#[wasm_bindgen]
+pub fn clipboard() -> Clipboard {
+    with_engine(|e| {
+        e.clipboard().map_or(JsValue::UNDEFINED, |clipboard| {
+            let object = Object::new();
+            let (kind, ids) = match clipboard.content.ids() {
+                engine::ClipboardIds::Files(ids) => ("files", uuids(ids, |id| id.0)),
+                engine::ClipboardIds::Tracks(ids) => ("tracks", uuids(ids, |id| id.0)),
+                engine::ClipboardIds::Segments(ids) => ("segments", uuids(ids, |id| id.0)),
+                engine::ClipboardIds::Waypoints(ids) => ("waypoints", uuids(ids, |id| id.0)),
+            };
+            set(&object, "type", kind);
+            set(&object, "ids", ids);
+            set(&object, "cut", clipboard.cut);
+            object.into()
+        })
+    })
+    .unwrap_or(JsValue::UNDEFINED)
+    .unchecked_into()
+}

gpx-rs/wasm/src/queries/mod.rs

@@ -0,0 +1,4 @@
+pub(crate) mod coordinates;
+pub(crate) mod files;
+pub(crate) mod routing;
+pub(crate) mod statistics;

gpx-rs/wasm/src/queries/routing.rs

@@ -0,0 +1,54 @@
+//! The anchors of the routing tool among the trackpoints of the selection.
+
+use gpx_engine as engine;
+use js_sys::{Uint8Array, Uint32Array};
+use wasm_bindgen::prelude::*;
+
+use crate::convert::*;
+use crate::session::*;
+use crate::ts::*;
+
+// Routing buffers
+//
+// The anchors of the routing tool among the trackpoints of the selection (the numbering is the one
+// of the statistics buffers). The ends of the segments are always anchors.
+
+pub(crate) fn with_routing<T>(f: impl FnOnce(&engine::RoutingBuffer) -> T) -> Option<T> {
+    ENGINE.with(|engine| engine.borrow().as_ref().map(|e| f(e.routing())))
+}
+
+/// The index in the selection of each anchor.
+#[wasm_bindgen]
+pub fn anchor_indices() -> Uint32Array {
+    with_routing(|r| Uint32Array::from(&r.anchor_indices[..]))
+        .unwrap_or_else(|| Uint32Array::new_with_length(0))
+}
+
+/// The lowest map zoom level at which each anchor is shown.
+#[wasm_bindgen]
+pub fn anchor_zooms() -> Uint8Array {
+    with_routing(|r| Uint8Array::from(&r.anchor_zooms[..]))
+        .unwrap_or_else(|| Uint8Array::new_with_length(0))
+}
+
+/// Index in the selection of the first trackpoint of each selected segment that has some.
+#[wasm_bindgen]
+pub fn segment_starts() -> Uint32Array {
+    with_routing(|r| Uint32Array::from(&r.segment_starts[..]))
+        .unwrap_or_else(|| Uint32Array::new_with_length(0))
+}
+
+/// The id of each selected segment that has trackpoints, as `segment_starts`.
+#[wasm_bindgen]
+pub fn segment_ids() -> StringList {
+    with_routing(|r| array(&r.segment_ids, |id| id.0.to_string().into()))
+        .unwrap_or_default()
+        .unchecked_into()
+}
+
+/// Changes when the selected segments or their trackpoints change: the indices in the selection
+/// are only valid while it stays the same.
+#[wasm_bindgen]
+pub fn routing_revision() -> u32 {
+    with_routing(|r| r.revision).unwrap_or_default()
+}

gpx-rs/wasm/src/queries/statistics.rs

@@ -0,0 +1,142 @@
+//! The statistics of the selection, as typed arrays, and the categories they refer to.
+
+use gpx_engine as engine;
+use js_sys::{BigInt64Array, Float64Array, Uint8Array, Uint32Array};
+use wasm_bindgen::prelude::*;
+
+use crate::convert::*;
+use crate::session::*;
+use crate::ts::*;
+
+// Statistics buffers
+//
+// Each getter returns a copy of the buffer, as a new JS typed array.
+
+pub(crate) fn with_stats<T>(f: impl FnOnce(&engine::StatisticsBuffer) -> T) -> Option<T> {
+    ENGINE.with(|engine| engine.borrow().as_ref().map(|e| f(e.statistics())))
+}
+
+macro_rules! stats_getter {
+    ($name:ident, $array:ident) => {
+        #[wasm_bindgen]
+        pub fn $name() -> $array {
+            with_stats(|s| $array::from(&s.$name[..])).unwrap_or_else(|| $array::new_with_length(0))
+        }
+    };
+}
+
+stats_getter!(total_distance, Float64Array);
+stats_getter!(elevation_gain, Float64Array);
+stats_getter!(elevation_loss, Float64Array);
+stats_getter!(slope, Float64Array);
+stats_getter!(slope_segment_slope, Float64Array);
+stats_getter!(slope_segment_distance, Float64Array);
+stats_getter!(lng, Float64Array);
+stats_getter!(lat, Float64Array);
+stats_getter!(ele, Float64Array);
+
+// The optional values are `undefined` when no trackpoint of the selection has one, else they have
+// an entry per trackpoint, the missing ones being NaN (`NO_TIME` for the timestamps, 0 before the
+// first trackpoint that has them for the cumulative distances and durations).
+macro_rules! optional_stats_getter {
+    ($name:ident, $field:ident, $array:ident) => {
+        #[wasm_bindgen]
+        pub fn $name() -> Option<$array> {
+            with_stats(|s| s.$field.as_deref().map($array::from)).flatten()
+        }
+    };
+}
+
+optional_stats_getter!(moving_distance, moving_distance, Float64Array);
+// Durations since the start of the selection, in milliseconds.
+optional_stats_getter!(total_time, total_time, BigInt64Array);
+optional_stats_getter!(moving_time, moving_time, BigInt64Array);
+optional_stats_getter!(speed, speed, Float64Array);
+// Timestamps in milliseconds since the epoch (`NO_TIME`, the smallest i64, when missing).
+optional_stats_getter!(timestamps, time, BigInt64Array);
+
+/// Value of the timestamps of the trackpoints that have none.
+#[wasm_bindgen]
+pub fn no_time() -> i64 {
+    engine::NO_TIME
+}
+
+optional_stats_getter!(hr, hr, Float64Array);
+optional_stats_getter!(cad, cad, Float64Array);
+optional_stats_getter!(atemp, atemp, Float64Array);
+optional_stats_getter!(power, power, Float64Array);
+
+// Surface, highway, SAC scale and MTB scale of the trackpoints, as intervals of trackpoints that
+// have the same value: `<name>_starts` holds the index of the first trackpoint of each interval,
+// and `<name>_values` its value (0 when unknown, else 1 + the index in `surfaces()`,
+// `highways()`, `sac_scales()` or `mtb_scales()`). A value that is unknown for every trackpoint is
+// a single interval.
+macro_rules! intervals_getters {
+    ($starts:ident, $values:ident, $field:ident) => {
+        #[wasm_bindgen]
+        pub fn $starts() -> Uint32Array {
+            with_stats(|s| Uint32Array::from(&s.$field.starts[..]))
+                .unwrap_or_else(|| Uint32Array::new_with_length(0))
+        }
+
+        #[wasm_bindgen]
+        pub fn $values() -> Uint8Array {
+            with_stats(|s| Uint8Array::from(&s.$field.values[..]))
+                .unwrap_or_else(|| Uint8Array::new_with_length(0))
+        }
+    };
+}
+
+intervals_getters!(surface_starts, surface_values, surface);
+intervals_getters!(highway_starts, highway_values, highway);
+intervals_getters!(sac_scale_starts, sac_scale_values, sac_scale);
+intervals_getters!(mtb_scale_starts, mtb_scale_values, mtb_scale);
+
+/// The names of the surfaces, in the order of their codes (see `surface_values`). The list only grows:
+/// a name keeps its index.
+#[wasm_bindgen]
+pub fn surfaces() -> StringList {
+    with_engine(|e| array(e.categories().surface.names(), |name| name.as_str().into()))
+        .unwrap_or_default()
+        .unchecked_into()
+}
+
+/// The names of the highways, in the order of their codes (see `highway_values`).
+#[wasm_bindgen]
+pub fn highways() -> StringList {
+    with_engine(|e| array(e.categories().highway.names(), |name| name.as_str().into()))
+        .unwrap_or_default()
+        .unchecked_into()
+}
+
+/// The names of the SAC scales, in the order of their codes (see `sac_scale_values`).
+#[wasm_bindgen]
+pub fn sac_scales() -> StringList {
+    with_engine(|e| {
+        array(e.categories().sac_scale.names(), |name| {
+            name.as_str().into()
+        })
+    })
+    .unwrap_or_default()
+    .unchecked_into()
+}
+
+/// The names of the MTB scales, in the order of their codes (see `mtb_scale_values`).
+#[wasm_bindgen]
+pub fn mtb_scales() -> StringList {
+    with_engine(|e| {
+        array(e.categories().mtb_scale.names(), |name| {
+            name.as_str().into()
+        })
+    })
+    .unwrap_or_default()
+    .unchecked_into()
+}
+
+/// For each trackpoint of the selection (numbered as in the statistics), the highest tolerance
+/// (m) of `reduce` that keeps it: infinite for the ends of the segments.
+#[wasm_bindgen]
+pub fn reduction_distances() -> Float64Array {
+    with_engine(|e| Float64Array::from(&e.reduction_distances()[..]))
+        .unwrap_or_else(|| Float64Array::new_with_length(0))
+}

gpx-rs/wasm/src/selection.rs

@@ -0,0 +1,110 @@
+//! Changing what is selected.
+
+use gpx_engine::{self as engine, Action};
+use wasm_bindgen::prelude::*;
+
+use crate::ts::Outcome;
+
+use crate::ids::*;
+use crate::session::*;
+use crate::types::SelectMode;
+
+// Selection
+
+/// Selects files. `file_ids_bytes`: concatenated 16-byte UUIDs. Unknown files are ignored, and
+/// selecting nothing deselects everything. See `SelectMode`.
+#[wasm_bindgen]
+pub fn select(file_ids_bytes: &[u8], mode: SelectMode) -> Outcome {
+    select_elements(
+        file_ids(file_ids_bytes).map(|ids| engine::Selection::File {
+            file_ids: ids.into_iter().collect(),
+        }),
+        mode,
+    )
+}
+
+/// Selects all the elements of the same kind as the selected ones, in the same place: all the
+/// files, the tracks of the file, the segments of the track, the waypoints of the file. All the
+/// files when nothing is selected.
+#[wasm_bindgen]
+pub fn select_all() -> Outcome {
+    execute(Action::SelectAll)
+}
+
+/// Moves the selection to the next (`down`) or previous element of the same kind, like the arrow
+/// keys do in the file list. With `add` (shift + arrow), the element is added to the selection,
+/// otherwise it replaces it.
+#[wasm_bindgen]
+pub fn arrow_select(down: bool, add: bool) -> Outcome {
+    execute(Action::ArrowSelect { down, add })
+}
+
+// The elements below cross as the id of their file (UUID string) and, like the files, as
+// concatenated 16-byte UUIDs. What does not exist is ignored. See `SelectMode`: elements are merged
+// with the selection when it holds elements of the same kind in the same place (same file, same
+// track for segments), otherwise they replace it.
+
+pub(crate) fn select_elements(selection: Option<engine::Selection>, mode: SelectMode) -> Outcome {
+    match selection {
+        Some(selection) => execute(Action::Select {
+            selection,
+            mode: mode.into(),
+        }),
+        None => fail("the ids are not UUIDs"),
+    }
+}
+
+#[wasm_bindgen]
+pub fn select_tracks(file_id: &str, track_ids_bytes: &[u8], mode: SelectMode) -> Outcome {
+    select_elements(
+        parse_file_id(file_id)
+            .zip(uuid_list(track_ids_bytes))
+            .map(|(file_id, ids)| engine::Selection::Track {
+                file_id,
+                trk_ids: ids.into_iter().map(engine::TrackId).collect(),
+            }),
+        mode,
+    )
+}
+
+#[wasm_bindgen]
+pub fn select_segments(
+    file_id: &str,
+    track_id: &str,
+    segment_ids_bytes: &[u8],
+    mode: SelectMode,
+) -> Outcome {
+    select_elements(
+        parse_file_id(file_id)
+            .zip(uuid::Uuid::parse_str(track_id).ok())
+            .zip(uuid_list(segment_ids_bytes))
+            .map(|((file_id, trk_id), ids)| engine::Selection::TrackSegment {
+                file_id,
+                trk_id: engine::TrackId(trk_id),
+                trkseg_ids: ids.into_iter().map(engine::TrackSegmentId).collect(),
+            }),
+        mode,
+    )
+}
+
+/// Selects the node standing for all the waypoints of a file.
+#[wasm_bindgen]
+pub fn select_waypoint_group(file_id: &str, mode: SelectMode) -> Outcome {
+    select_elements(
+        parse_file_id(file_id).map(|file_id| engine::Selection::Waypoints { file_id }),
+        mode,
+    )
+}
+
+#[wasm_bindgen]
+pub fn select_waypoints(file_id: &str, waypoint_ids_bytes: &[u8], mode: SelectMode) -> Outcome {
+    select_elements(
+        parse_file_id(file_id)
+            .zip(uuid_list(waypoint_ids_bytes))
+            .map(|(file_id, ids)| engine::Selection::Waypoint {
+                file_id,
+                wpt_ids: ids.into_iter().map(engine::WaypointId).collect(),
+            }),
+        mode,
+    )
+}

gpx-rs/wasm/src/session.rs

@@ -0,0 +1,52 @@
+//! The engine that every function talks to, and the way actions reach it.
+
+use std::cell::RefCell;
+
+use gpx_engine::{self as engine, Action, Command, Engine};
+use wasm_bindgen::prelude::*;
+
+use crate::convert::outcome_object;
+use crate::persistence::schedule_save;
+use crate::ts::Outcome;
+
+thread_local! {
+    pub(crate) static ENGINE: RefCell<Option<Engine>> = const { RefCell::new(None) };
+}
+
+/// What a call that does nothing returns, when the reason is in its arguments rather than in the
+/// engine: the call is not made.
+pub(crate) fn fail(message: impl AsRef<str>) -> Outcome {
+    outcome_object(&engine::Outcome::default(), Some(message.as_ref()))
+}
+
+/// Runs an action and tells what it did, see `Outcome` in `ts`.
+pub(crate) fn execute(action: Action) -> Outcome {
+    let Some(outcome) = with_engine_mut(|engine| engine.execute(action)) else {
+        return fail("the engine is not started");
+    };
+    if outcome.changed && (outcome.diff.is_some() || outcome.order_changed) {
+        schedule_save();
+    }
+    let error = outcome.error.as_ref().map(ToString::to_string);
+    outcome_object(&outcome, error.as_deref())
+}
+
+pub(crate) fn edit(command: Command) -> Outcome {
+    execute(Action::Edit(command))
+}
+
+#[wasm_bindgen]
+pub fn start() {
+    console_error_panic_hook::set_once();
+    ENGINE.with(|engine| {
+        *engine.borrow_mut() = Some(Engine::default());
+    });
+}
+
+pub(crate) fn with_engine<T>(f: impl FnOnce(&Engine) -> T) -> Option<T> {
+    ENGINE.with(|engine| engine.borrow().as_ref().map(f))
+}
+
+pub(crate) fn with_engine_mut<T>(f: impl FnOnce(&mut Engine) -> T) -> Option<T> {
+    ENGINE.with(|engine| engine.borrow_mut().as_mut().map(f))
+}

gpx-rs/wasm/src/tests.rs

@@ -0,0 +1,482 @@
+//! Tests of the JS interface, run with `wasm-pack test --node wasm` (they need a JS environment).
+//!
+//! Every test starts a new engine, which is what the page does once.
+
+#![allow(clippy::needless_borrows_for_generic_args)]
+
+use js_sys::{Array, BigInt64Array, Float64Array, Object, Reflect};
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_test::*;
+
+use crate::command::history::*;
+use crate::session::*;
+use crate::ts::Outcome;
+use crate::types::*;
+
+const SIMPLE: &[u8] = include_bytes!("../../engine/data/simple.gpx");
+const WITH_TIME: &[u8] = include_bytes!("../../engine/data/with_time.gpx");
+const WITH_SURFACE: &[u8] = include_bytes!("../../engine/data/with_surface.gpx");
+
+thread_local! {
+    static LAST: std::cell::RefCell<JsValue> = const { std::cell::RefCell::new(JsValue::UNDEFINED) };
+}
+
+/// Keeps the outcome of a call for the checks that follow it, and tells whether it changed anything.
+fn run(outcome: Outcome) -> bool {
+    let outcome = JsValue::from(outcome);
+    let changed = get(&outcome, "changed").as_bool().unwrap();
+    LAST.with(|last| *last.borrow_mut() = outcome);
+    changed
+}
+
+fn last_outcome() -> JsValue {
+    LAST.with(|last| last.borrow().clone())
+}
+
+fn last_error() -> Option<String> {
+    get(&last_outcome(), "error").as_string()
+}
+
+fn get(object: impl AsRef<JsValue>, key: &str) -> JsValue {
+    Reflect::get(object.as_ref(), &key.into()).unwrap()
+}
+
+fn array(value: impl Into<JsValue>) -> Array {
+    Array::from(&value.into())
+}
+
+fn strings(value: impl Into<JsValue>) -> Vec<String> {
+    array(value)
+        .iter()
+        .map(|v| v.as_string().unwrap())
+        .collect()
+}
+
+/// Starts a new engine and loads the given files (one command).
+fn started_with(files: &[(&[u8], &str)]) {
+    start();
+    if files.is_empty() {
+        return;
+    }
+    let data: Vec<u8> = files
+        .iter()
+        .flat_map(|(data, _)| data.iter().copied())
+        .collect();
+    let lengths: Vec<u32> = files.iter().map(|(data, _)| data.len() as u32).collect();
+    let names = files.iter().map(|(_, name)| name.to_string()).collect();
+    assert!(run(crate::command::files::load_files(
+        &data, &lengths, names
+    )));
+}
+
+fn order() -> Vec<String> {
+    strings(crate::queries::files::file_order())
+}
+
+fn uuid_bytes(ids: &[String]) -> Vec<u8> {
+    ids.iter()
+        .flat_map(|id| *uuid::Uuid::parse_str(id).unwrap().as_bytes())
+        .collect()
+}
+
+#[wasm_bindgen_test]
+fn test_new_file_is_listed_and_selected() {
+    start();
+    assert!(run(crate::command::files::new_file(
+        "route", None, None, None
+    )));
+    assert_eq!(last_error(), None);
+
+    let ids = order();
+    assert_eq!(ids.len(), 1);
+    let structure = crate::queries::files::file_structure(&ids[0]);
+    assert_eq!(
+        get(&structure, "name").as_string().as_deref(),
+        Some("route")
+    );
+    assert_eq!(array(get(&structure, "tracks")).length(), 0);
+
+    let selection = crate::queries::files::selection();
+    assert_eq!(get(&selection, "type").as_string().as_deref(), Some("file"));
+    assert_eq!(strings(get(&selection, "fileIds")), ids);
+
+    let update = last_outcome();
+    assert_eq!(strings(get(&update, "added")), ids);
+    assert_eq!(get(&update, "orderChanged").as_bool(), Some(true));
+}
+
+#[wasm_bindgen_test]
+fn test_unknown_file_has_no_structure() {
+    started_with(&[]);
+    let id = uuid::Uuid::new_v4().to_string();
+    assert!(crate::queries::files::file_structure(&id).is_undefined());
+    assert!(crate::queries::files::file_structure("not an id").is_undefined());
+    assert!(crate::queries::files::file_statistics(&id).is_undefined());
+    assert!(crate::queries::files::export_file(&id, true, true, true, true, true, true).is_none());
+    assert_eq!(
+        crate::queries::coordinates::segment_coordinates(&id).length(),
+        0
+    );
+    assert_eq!(
+        crate::queries::coordinates::waypoint_coordinates("nope").length(),
+        0
+    );
+}
+
+#[wasm_bindgen_test]
+fn test_loaded_file_has_statistics_and_coordinates() {
+    started_with(&[(SIMPLE, "simple")]);
+    let id = order().remove(0);
+
+    let stats = crate::queries::files::file_statistics(&id);
+    assert!(get(&stats, "totalDistance").as_f64().unwrap() > 0.0);
+    // the file is selected: the buffers describe it
+    let selection_stats = crate::queries::files::selection_statistics();
+    assert_eq!(
+        get(&selection_stats, "totalDistance").as_f64(),
+        get(&stats, "totalDistance").as_f64()
+    );
+    let n = crate::queries::statistics::total_distance().length();
+    assert!(n > 0);
+    assert_eq!(crate::queries::statistics::lng().length(), n);
+    assert_eq!(crate::queries::statistics::ele().length(), n);
+    // no timestamps in this file
+    assert!(crate::queries::statistics::timestamps().is_none());
+
+    let structure = crate::queries::files::file_structure(&id);
+    let segment = get(
+        &array(get(&array(get(&structure, "tracks")).get(0), "segments")).get(0),
+        "id",
+    );
+    let coordinates =
+        crate::queries::coordinates::segment_coordinates(&segment.as_string().unwrap());
+    assert_eq!(coordinates.length(), 2 * n);
+
+    // the routing buffers: one segment, anchored at both ends
+    assert_eq!(crate::queries::routing::segment_starts().to_vec(), vec![0]);
+    let anchors = crate::queries::routing::anchor_indices().to_vec();
+    assert_eq!(anchors.first(), Some(&0));
+    assert_eq!(anchors.last(), Some(&(n - 1)));
+}
+
+#[wasm_bindgen_test]
+fn test_timestamps_and_categories() {
+    started_with(&[(WITH_TIME, "time")]);
+    let times: BigInt64Array = crate::queries::statistics::timestamps().unwrap();
+    assert!(times.length() > 0);
+    assert!(crate::queries::statistics::total_time().is_some());
+
+    started_with(&[(WITH_SURFACE, "surface")]);
+    let surfaces = strings(crate::queries::statistics::surfaces());
+    assert!(!surfaces.is_empty());
+    let values = crate::queries::statistics::surface_values().to_vec();
+    assert!(values.iter().any(|v| *v > 0));
+    assert!(values.iter().all(|v| (*v as usize) <= surfaces.len()));
+    assert_eq!(
+        crate::queries::statistics::surface_starts().length(),
+        values.len() as u32
+    );
+}
+
+#[wasm_bindgen_test]
+fn test_the_reason_of_a_failure_can_be_read() {
+    started_with(&[]);
+
+    // nothing to do
+    assert!(!run(crate::command::tools::reverse()));
+    assert_eq!(last_error().as_deref(), Some("nothing to do"));
+    // the next call starts afresh
+    assert!(run(crate::command::files::new_file("a", None, None, None)));
+    assert_eq!(last_error(), None);
+
+    // invalid data
+    assert!(!run(crate::command::files::load_files(
+        b"<gpx><trk></gpx>",
+        &[16],
+        vec!["bad".into()]
+    )));
+    assert!(last_error().unwrap().starts_with("invalid data"));
+    assert_eq!(order().len(), 1);
+
+    // arguments that do not make sense
+    assert!(!run(crate::command::files::load_files(
+        b"",
+        &[1, 2],
+        vec!["a".into()]
+    )));
+    assert!(last_error().unwrap().contains("lengths"));
+    assert!(!run(crate::command::files::load_files(
+        b"abc",
+        &[10],
+        vec!["a".into()]
+    )));
+    assert!(last_error().unwrap().contains("shorter"));
+    assert!(!run(crate::command::files::reorder(&[1, 2, 3], 0)));
+    assert!(last_error().unwrap().contains("UUIDs"));
+    assert!(!run(crate::command::tools::crop(5, 1)));
+    assert!(last_error().unwrap().contains("reversed"));
+    assert!(!run(crate::command::waypoints::delete_waypoint("x", "y")));
+    assert!(last_error().unwrap().contains("UUID"));
+    assert!(!run(crate::selection::select_tracks(
+        "x",
+        &[],
+        SelectMode::Replace
+    )));
+    assert!(last_error().unwrap().contains("UUIDs"));
+
+    // a stale revision
+    let stale = crate::queries::routing::routing_revision().wrapping_add(1);
+    assert!(!run(crate::command::routing::insert_anchor(
+        stale, 0.0, 0.0
+    )));
+    assert!(last_error().unwrap().contains("routing buffers"));
+    assert!(!run(crate::command::routing::change_loop_start(stale, 0)));
+    assert!(!run(crate::command::routing::split(
+        stale,
+        0,
+        SplitType::Files
+    )));
+    assert!(last_error().is_some());
+
+    // answers are not failures
+    assert!(run(crate::command::files::new_file("b", None, None, None)));
+    assert!(!crate::command::files::can_paste());
+    assert_eq!(last_error(), None);
+}
+
+#[wasm_bindgen_test]
+fn test_undo_and_redo() {
+    started_with(&[]);
+    assert!(!can_undo() && !can_redo());
+    assert!(run(crate::command::files::new_file("a", None, None, None)));
+    assert!(can_undo() && !can_redo());
+    assert!(run(undo()));
+    assert!(order().is_empty());
+    assert!(can_redo());
+    assert!(run(redo()));
+    assert_eq!(order().len(), 1);
+    // nothing to redo is not an error of the engine
+    assert!(!run(redo()));
+}
+
+#[wasm_bindgen_test]
+fn test_export_and_exportable_data() {
+    started_with(&[(SIMPLE, "plain"), (WITH_TIME, "timed")]);
+    let ids = order();
+
+    let bytes =
+        crate::queries::files::export_file(&ids[0], true, true, true, true, true, true).unwrap();
+    assert!(String::from_utf8(bytes).unwrap().contains("<gpx"));
+
+    // the time is the first bit
+    assert_eq!(
+        crate::queries::files::exportable_data(&uuid_bytes(&ids[..1])) & 1,
+        0
+    );
+    assert_eq!(
+        crate::queries::files::exportable_data(&uuid_bytes(&ids[1..])) & 1,
+        1
+    );
+    assert_eq!(
+        crate::queries::files::exportable_data(&uuid_bytes(&ids)) & 1,
+        1
+    );
+    assert_eq!(crate::queries::files::exportable_data(&[1, 2, 3]), 0);
+}
+
+#[wasm_bindgen_test]
+fn test_select_and_reorder_files() {
+    started_with(&[(SIMPLE, "a"), (WITH_TIME, "b")]);
+    let ids = order();
+
+    assert!(run(crate::selection::select(
+        &uuid_bytes(&ids[1..]),
+        SelectMode::Replace
+    )));
+    assert_eq!(
+        strings(get(&crate::queries::files::selection(), "fileIds")),
+        ids[1..]
+    );
+    assert!(run(crate::selection::select(
+        &uuid_bytes(&ids[..1]),
+        SelectMode::Add
+    )));
+    assert_eq!(
+        array(get(&crate::queries::files::selection(), "fileIds")).length(),
+        2
+    );
+    assert!(run(crate::selection::select(
+        &uuid_bytes(&ids[..1]),
+        SelectMode::Toggle
+    )));
+    assert_eq!(
+        strings(get(&crate::queries::files::selection(), "fileIds")),
+        ids[1..]
+    );
+
+    // reordering is a change of the order, nothing else
+    let reversed: Vec<String> = ids.iter().rev().cloned().collect();
+    assert!(run(crate::command::files::reorder(
+        &uuid_bytes(&reversed[..1]),
+        0
+    )));
+    assert_eq!(order(), reversed);
+    assert_eq!(get(&last_outcome(), "orderChanged").as_bool(), Some(true));
+}
+
+#[wasm_bindgen_test]
+fn test_move_elements_takes_js_objects() {
+    started_with(&[(SIMPLE, "a"), (WITH_TIME, "b")]);
+    let ids = order();
+    assert!(run(crate::selection::select(
+        &uuid_bytes(&ids[1..]),
+        SelectMode::Replace
+    )));
+
+    let target = Object::new();
+    Reflect::set(&target, &"type".into(), &"files".into()).unwrap();
+    Reflect::set(&target, &"index".into(), &0.into()).unwrap();
+    let what = JsValue::from(crate::queries::files::selection());
+    assert!(run(crate::command::files::move_elements(
+        what.clone().unchecked_into(),
+        JsValue::from(target).unchecked_into()
+    )));
+    assert_eq!(order(), vec![ids[1].clone(), ids[0].clone()]);
+
+    // an unknown target
+    let bad = Object::new();
+    Reflect::set(&bad, &"type".into(), &"nowhere".into()).unwrap();
+    Reflect::set(&bad, &"index".into(), &0.into()).unwrap();
+    assert!(!run(crate::command::files::move_elements(
+        what.unchecked_into(),
+        JsValue::from(bad).unchecked_into()
+    )));
+    assert!(last_error().unwrap().contains("not valid"));
+}
+
+#[wasm_bindgen_test]
+fn test_waypoints() {
+    started_with(&[]);
+    assert!(run(crate::command::files::new_file(
+        "file", None, None, None
+    )));
+    let file = order().remove(0);
+    assert!(run(crate::command::waypoints::new_waypoint(
+        4.0, 50.0, 100.0, "summit", "", "", ""
+    )));
+
+    let structure = crate::queries::files::file_structure(&file);
+    let waypoints = array(get(&structure, "waypoints"));
+    assert_eq!(waypoints.length(), 1);
+    let id = get(&waypoints.get(0), "id").as_string().unwrap();
+    let details = crate::queries::files::waypoint(&file, &id);
+    assert_eq!(get(&details, "name").as_string().as_deref(), Some("summit"));
+    assert_eq!(get(&details, "ele").as_f64(), Some(100.0));
+    assert_eq!(
+        crate::queries::coordinates::waypoint_coordinates(&file).to_vec(),
+        vec![4.0, 50.0]
+    );
+
+    assert!(run(crate::command::waypoints::update_waypoint(
+        &file, &id, 5.0, 51.0, 120.0, "peak", "", "", ""
+    )));
+    let details = crate::queries::files::waypoint(&file, &id);
+    assert_eq!(get(&details, "name").as_string().as_deref(), Some("peak"));
+    assert!(run(crate::command::waypoints::move_waypoint(
+        &file, &id, 6.0, 52.0, 130.0
+    )));
+    assert_eq!(
+        crate::queries::coordinates::waypoint_coordinates(&file).to_vec(),
+        vec![6.0, 52.0]
+    );
+
+    // the structure tells the coordinates changed
+    let rev = get(
+        &crate::queries::files::file_structure(&file),
+        "waypointsRev",
+    );
+    assert!(run(crate::command::waypoints::move_waypoint(
+        &file, &id, 7.0, 52.0, 130.0
+    )));
+    assert_ne!(
+        get(
+            &crate::queries::files::file_structure(&file),
+            "waypointsRev"
+        ),
+        rev
+    );
+
+    assert!(run(crate::command::waypoints::delete_waypoint(&file, &id)));
+    assert!(crate::queries::files::waypoint(&file, &id).is_undefined());
+    // already gone
+    assert!(!run(crate::command::waypoints::delete_waypoint(&file, &id)));
+    assert!(last_error().is_some());
+}
+
+#[wasm_bindgen_test]
+fn test_clipboard() {
+    started_with(&[(SIMPLE, "a")]);
+    assert!(crate::queries::files::clipboard().is_undefined());
+    assert!(run(crate::command::files::copy()));
+    let clipboard = crate::queries::files::clipboard();
+    assert_eq!(
+        get(&clipboard, "type").as_string().as_deref(),
+        Some("files")
+    );
+    assert_eq!(get(&clipboard, "cut").as_bool(), Some(false));
+    assert!(crate::command::files::can_paste());
+    assert!(run(crate::command::files::paste()));
+    assert_eq!(order().len(), 2);
+}
+
+#[wasm_bindgen_test]
+fn test_editing_tools_change_the_statistics() {
+    started_with(&[(SIMPLE, "a")]);
+    let before = crate::queries::statistics::total_distance().length();
+    assert!(run(crate::command::tools::crop(0, 9)));
+    assert_eq!(crate::queries::statistics::total_distance().length(), 10);
+    assert!(run(undo()));
+    assert_eq!(
+        crate::queries::statistics::total_distance().length(),
+        before
+    );
+
+    // one elevation per trackpoint
+    let ele = Float64Array::new_with_length(before);
+    assert!(run(crate::command::tools::elevation(&ele.to_vec())));
+    assert!(
+        crate::queries::statistics::ele()
+            .to_vec()
+            .iter()
+            .all(|e| *e == 0.0)
+    );
+    assert!(!run(crate::command::tools::elevation(&[1.0])));
+    assert!(last_error().unwrap().contains("elevations"));
+
+    assert!(
+        run(crate::command::tools::reduce(5.0)) || last_error().as_deref() == Some("nothing to do")
+    );
+    assert!(crate::queries::statistics::total_distance().length() <= before);
+}
+
+#[wasm_bindgen_test]
+fn test_last_update_describes_the_last_call_only() {
+    started_with(&[]);
+    assert!(run(crate::command::files::new_file("a", None, None, None)));
+    let update = last_outcome();
+    assert_eq!(array(get(&update, "added")).length(), 1);
+    assert_eq!(get(&update, "orderChanged").as_bool(), Some(true));
+
+    // a call that does nothing replaces it, whether the engine refuses or the arguments are wrong
+    assert!(!run(crate::command::tools::reverse()));
+    let update = last_outcome();
+    assert_eq!(array(get(&update, "added")).length(), 0);
+    assert_eq!(get(&update, "orderChanged").as_bool(), Some(false));
+    assert_eq!(get(&update, "selectionChanged").as_bool(), Some(false));
+
+    assert!(run(crate::command::files::new_file("b", None, None, None)));
+    assert!(!run(crate::command::tools::crop(3, 1)));
+    let update = last_outcome();
+    assert_eq!(array(get(&update, "added")).length(), 0);
+    assert_eq!(get(&update, "orderChanged").as_bool(), Some(false));
+}

gpx-rs/wasm/src/ts.rs

@@ -0,0 +1,191 @@
+//! The TypeScript types of the JS objects, which the functions declare in their signatures.
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(typescript_custom_section)]
+const ROUTE_TS: &str = r#"
+/**
+ * An OSM attribute of the new trackpoints of a route, as the intervals of trackpoints that share
+ * a value: `starts[i]` is the index of the first trackpoint of the interval `i`, and `values[i]`
+ * its value, 0 when unknown, else 1 + the index of its name in `names`.
+ */
+export interface RouteCategory {
+    starts: Uint32Array;
+    values: Uint8Array;
+    names: string[];
+}
+/** The attributes of the new trackpoints of a route. The ones that are missing are unknown. */
+export interface RouteAttributes {
+    surface?: RouteCategory;
+    highway?: RouteCategory;
+    sacScale?: RouteCategory;
+    mtbScale?: RouteCategory;
+}
+"#;
+
+#[wasm_bindgen(typescript_custom_section)]
+const FILE_STRUCTURE_TS: &str = r#"
+export type Selection =
+    | { type: 'empty' }
+    | { type: 'file'; fileIds: string[] }
+    | { type: 'track'; fileId: string; trackIds: string[] }
+    | { type: 'segment'; fileId: string; trackId: string; segmentIds: string[] }
+    | { type: 'waypoints'; fileId: string }
+    | { type: 'waypoint'; fileId: string; waypointIds: string[] };
+/**
+ * Where moved elements go: a list of the file tree and the position in it, counted among the
+ * elements of the list that are not moved.
+ */
+export type MoveTarget =
+    | { type: 'files'; index: number }
+    | { type: 'tracks'; fileId: string; index: number }
+    | { type: 'segments'; fileId: string; trackId: string; index: number }
+    | { type: 'waypoints'; fileId: string; index: number };
+/** All the data of a waypoint. The fields it does not have are absent. */
+export interface WaypointDetails {
+    id: string;
+    lng: number;
+    lat: number;
+    ele: number;
+    /** ms since epoch */
+    time?: number;
+    name?: string;
+    desc?: string;
+    cmt?: string;
+    link?: { href: string; text?: string };
+    sym?: string;
+}
+/** The position, elevation and time of a trackpoint. */
+export interface TrackpointDetails {
+    lng: number;
+    lat: number;
+    ele: number;
+    /** ms since epoch */
+    time?: number;
+}
+/** What was copied or cut, to be pasted: the kind of the elements and their ids. */
+export interface Clipboard {
+    type: 'files' | 'tracks' | 'segments' | 'waypoints';
+    ids: string[];
+    cut: boolean;
+}
+/** What changed in the files, the selection and the clipboard. */
+export interface FilesUpdate {
+    orderChanged: boolean;
+    selectionChanged: boolean;
+    clipboardChanged: boolean;
+    /** Files to read the structure of. */
+    added: string[];
+    /** Files whose structure changed: reread it. */
+    modified: string[];
+    /** Files that do not exist anymore: drop their structure. */
+    removed: string[];
+}
+/**
+ * What a call that edits the files or changes the selection did. `changed` is whether anything
+ * did; `error` tells why not (nothing to do, invalid data, or what is wrong with the arguments).
+ * Apply the update to what is kept of the files before the next call.
+ */
+export interface Outcome extends FilesUpdate {
+    changed: boolean;
+    error?: string;
+}
+/** What opening the storage found. */
+export interface StorageOpened {
+    /** The settings, as JSON strings by key. */
+    settings: Record<string, string>;
+    /** The files that were restored are the added ones. */
+    outcome: Outcome;
+    /** Some of what is stored was written by a newer version: nothing is saved. */
+    readOnly: boolean;
+    /** How many stored files could not be read, and are dropped at the next save. */
+    unreadable: number;
+}
+export interface FileStructure {
+    id: string;
+    name: string;
+    desc?: string;
+    tracks: TrackNode[];
+    waypoints: WaypointNode[];
+    /** Changes when the waypoints of the file change: refetch their coordinates. */
+    waypointsRev: string;
+}
+/**
+ * Global statistics of a file, of the selection, or of a part of it. The optional fields are
+ * absent when there is no data for them (no timestamps, no heart rate...).
+ */
+export interface GlobalStatistics {
+    /** km */
+    totalDistance: number;
+    movingDistance?: number;
+    /** seconds */
+    totalTime?: number;
+    movingTime?: number;
+    elevationGain: number;
+    elevationLoss: number;
+    /** ms since epoch */
+    startTime?: number;
+    endTime?: number;
+    /** km/h */
+    totalSpeed?: number;
+    movingSpeed?: number;
+    /** Average and number of trackpoints having the measure. */
+    hr?: { avg: number; count: number };
+    cad?: { avg: number; count: number };
+    atemp?: { avg: number; count: number };
+    power?: { avg: number; count: number };
+    /** Absent when there are no trackpoints. */
+    bounds?: { west: number; south: number; east: number; north: number };
+}
+export interface TrackNode {
+    id: string;
+    name?: string;
+    desc?: string;
+    /** Style of the track, only present when the file defines it. */
+    color?: string;
+    opacity?: number;
+    width?: number;
+    segments: SegmentNode[];
+}
+export interface SegmentNode {
+    id: string;
+    /** Changes when the trackpoints of the segment change: refetch their coordinates. */
+    rev: string;
+    /** Number of trackpoints. */
+    length: number;
+}
+export interface WaypointNode {
+    id: string;
+    name?: string;
+    sym?: string;
+}
+"#;
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "Selection")]
+    pub type Selection;
+    #[wasm_bindgen(typescript_type = "WaypointDetails | undefined")]
+    pub type WaypointDetails;
+    #[wasm_bindgen(typescript_type = "TrackpointDetails | undefined")]
+    pub type TrackpointDetails;
+    #[wasm_bindgen(typescript_type = "MoveTarget")]
+    pub type MoveTarget;
+
+    #[wasm_bindgen(typescript_type = "RouteAttributes")]
+    pub type RouteAttributes;
+    #[wasm_bindgen(typescript_type = "Clipboard | undefined")]
+    pub type Clipboard;
+    #[wasm_bindgen(typescript_type = "Outcome")]
+    pub type Outcome;
+    #[wasm_bindgen(typescript_type = "StorageOpened")]
+    pub type StorageOpened;
+    #[wasm_bindgen(typescript_type = "FileStructure | undefined")]
+    pub type FileStructure;
+    #[wasm_bindgen(typescript_type = "GlobalStatistics | undefined")]
+    pub type GlobalStatistics;
+    #[wasm_bindgen(typescript_type = "string[]")]
+    pub type FileOrder;
+    #[wasm_bindgen(typescript_type = "string[]")]
+    pub type StringList;
+}

gpx-rs/wasm/src/types.rs

@@ -0,0 +1,75 @@
+//! The enumerations that cross to JS, and their engine counterparts.
+
+use gpx_engine as engine;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[derive(Clone, Copy)]
+pub enum MergeType {
+    Connect,
+    Group,
+}
+
+/// What a split cuts in two.
+#[wasm_bindgen]
+#[derive(Clone, Copy)]
+pub enum SplitType {
+    Files,
+    Tracks,
+    Segments,
+}
+
+impl From<SplitType> for engine::SplitType {
+    fn from(t: SplitType) -> Self {
+        match t {
+            SplitType::Files => Self::Files,
+            SplitType::Tracks => Self::Tracks,
+            SplitType::Segments => Self::Segments,
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Copy)]
+pub enum CleanType {
+    Inside,
+    Outside,
+}
+
+/// How a selection combines with the current one: `Replace` it, `Add` to it, or `Toggle` the
+/// elements (the ones already selected are removed).
+#[wasm_bindgen]
+#[derive(Clone, Copy)]
+pub enum SelectMode {
+    Replace,
+    Add,
+    Toggle,
+}
+
+impl From<SelectMode> for engine::SelectMode {
+    fn from(m: SelectMode) -> Self {
+        match m {
+            SelectMode::Replace => Self::Replace,
+            SelectMode::Add => Self::Add,
+            SelectMode::Toggle => Self::Toggle,
+        }
+    }
+}
+
+impl From<MergeType> for engine::MergeType {
+    fn from(t: MergeType) -> Self {
+        match t {
+            MergeType::Connect => Self::Connect,
+            MergeType::Group => Self::Group,
+        }
+    }
+}
+
+impl From<CleanType> for engine::CleanType {
+    fn from(t: CleanType) -> Self {
+        match t {
+            CleanType::Inside => Self::Inside,
+            CleanType::Outside => Self::Outside,
+        }
+    }
+}