@signalk/tracks-plugin 3.0.0-beta.7 → 3.0.1

package/README.md

@@ -6,6 +6,8 @@ Positions are recorded to a SQLite file in the plugin's data directory, at a con
 resolution, so tracks survive a restart with no other plugin required. The plugin is enabled on
 install and needs no configuration to start recording.
 
+Requires Signal K server >= 2.33.0 for the v2 Track API; older servers get the v1 routes only.
+
 | Setting                                        | Behaviour                                                                      |
 | ---------------------------------------------- | ------------------------------------------------------------------------------ |
 | Track resolution                               | Minimum spacing between recorded positions.                                    |

package/dist/buildTypecheck.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -816,15 +816,16 @@ function createTrackProvider(deps) {
 *
 * `epsilon` implies `simplify=true`, so an explicit tolerance is honoured
 * whether or not the flag came with it. `simplify` alone leaves the tolerance
-* to the provider: the spec says "a tolerance suited to the size of the box",
-* and the extent of the track *as thinning left it* is the honest basis for
-* that — a query bbox may be absent, and when present it is what the client
-* searched in rather than what came back. It cannot be the simplified extent,
-* since that is the thing being computed.
+* to the provider, and the spec asks for one "suited to the size of the box":
+* with a `bbox` it is sized to that box, which for a chart viewer is its view,
+* so detail follows the zoom. With no box the choice is the provider's, and
+* the extent of the track *as thinning left it* stands in -- not the
+* simplified extent, since that is the thing being computed. A `bbox` without
+* `simplify` simplifies nothing.
 *
-* Chosen from the whole track rather than per segment, so every leg of one
-* track is simplified to the same tolerance and the single reported `epsilon`
-* describes all of them.
+* Chosen once per track rather than per segment, so every leg of one track is
+* simplified to the same tolerance and the single reported `epsilon` describes
+* all of them.
 *
 * A non-positive `epsilon` is not reachable through the API — the schema
 * declares `exclusiveMinimum: 0`, so the server rejects it — and is treated
@@ -835,16 +836,20 @@ function createTrackProvider(deps) {
 function chooseEpsilon(points, query) {
 	const explicit = query.epsilon;
 	if (explicit !== void 0 && explicit > 0) return explicit;
-	return query.simplify === true ? autoEpsilon(points) : void 0;
+	if (query.simplify !== true) return;
+	if (query.bbox) return extentEpsilon(query.bbox);
+	const bounds = boundsOf(points);
+	return bounds ? extentEpsilon(bounds) : void 0;
 }
 /**
-* How much of a track's own extent the automatic tolerance may deviate by.
+* How much of an extent -- the query box, or the track without one -- the
+* automatic tolerance may deviate by.
 *
-* One part in a thousand. Provisional while the v2 API is designed in
-* SignalK/signalk-server#2504: it is only a provider-chosen default for
-* `simplify` without an explicit epsilon, and a client that calibrates against
-* the exact ratio rather than reading the reported `epsilon` back would make
-* it expensive to change.
+* One part in a thousand: across a view that is roughly one screen pixel.
+* Provisional while the v2 API is designed in SignalK/signalk-server#2504: it
+* is only a provider-chosen default for `simplify` without an explicit
+* epsilon, and a client that calibrates against the exact ratio rather than
+* reading the reported `epsilon` back would make it expensive to change.
 */
 var AUTO_EPSILON_DIVISOR = 1e3;
 /**
@@ -856,17 +861,15 @@ var AUTO_EPSILON_DIVISOR = 1e3;
 */
 var MIN_AUTO_EPSILON = 1;
 /**
-* A tolerance scaled to how much ground a track covers.
+* A tolerance scaled to how much ground an extent covers.
 *
-* One part in a thousand of the track's diagonal: enough to drop the jitter of
-* a boat holding station while keeping every turn a passage is made of. A
-* fixed metre value cannot do both — 10 m erases nothing on an ocean crossing
-* and erases a marina approach entirely.
+* One part in a thousand of its diagonal. For a track that drops the jitter of
+* a boat holding station while keeping every turn a passage is made of; for a
+* view it keeps what a pixel can show. A fixed metre value cannot do either —
+* 10 m erases nothing on an ocean crossing and erases a marina approach
+* entirely.
 */
-function autoEpsilon(points) {
-	const bounds = boundsOf(points);
-	if (!bounds) return;
-	const [west, south, east, north] = bounds;
+function extentEpsilon([west, south, east, north]) {
 	const midLat = (south + north) / 2;
 	const height = (north - south) * M_PER_DEG;
 	const width = (east >= west ? east - west : east + 360 - west) * M_PER_DEG * Math.cos(midLat * Math.PI / 180);
@@ -12186,6 +12189,12 @@ var SqliteTrackStore = class {
 	debug;
 	/** Timestamp of the last position stored per context, for throttling. */
 	lastStored = /* @__PURE__ */ new Map();
+	/**
+	* The stored name per context, dated by its newest report. A name arrives
+	* with every position, so a repeat is answered here instead of committing a
+	* row that has not changed.
+	*/
+	lastName = /* @__PURE__ */ new Map();
 	constructor(config, debug) {
 		this.maxCells = config.maxCells ?? DEFAULT_MAX_CELLS;
 		this.segmentGap = config.segmentGap ?? DEFAULT_SEGMENT_GAP;
@@ -12347,7 +12356,16 @@ var SqliteTrackStore = class {
 	recordName(context, name, timestamp = Date.now()) {
 		const trimmed = name.trim();
 		if (trimmed === "") return;
-		this.insertName.run(context, trimmed, timestamp);
+		const seen = this.lastName.get(context);
+		if (seen && seen.timestamp > timestamp) return;
+		if (seen?.name === trimmed) {
+			seen.timestamp = timestamp;
+			return;
+		}
+		if (Number(this.insertName.run(context, trimmed, timestamp).changes) > 0) this.lastName.set(context, {
+			name: trimmed,
+			timestamp
+		});
 	}
 	nameFor(context) {
 		return this.selectName.get(context)?.name;
@@ -12356,7 +12374,10 @@ var SqliteTrackStore = class {
 		const cutoff = Date.now() - maxAge;
 		const dropped = this.db.prepare("SELECT context FROM positions GROUP BY context HAVING MAX(timestamp) < ? AND context IS NOT ?").all(cutoff, keep ?? null);
 		this.db.prepare("DELETE FROM positions WHERE context IN (SELECT context FROM positions GROUP BY context HAVING MAX(timestamp) < ?) AND context IS NOT ?").run(cutoff, keep ?? null);
-		for (const { context } of dropped) this.db.prepare("DELETE FROM names WHERE context = ?").run(context);
+		for (const { context } of dropped) {
+			this.db.prepare("DELETE FROM names WHERE context = ?").run(context);
+			this.lastName.delete(context);
+		}
 		for (const { context } of dropped) this.lastStored.delete(context);
 		if (this.retention > 0) {
 			const oldest = Date.now() - this.retention;
@@ -12365,7 +12386,14 @@ var SqliteTrackStore = class {
 		}
 	}
 	close() {
-		this.db.close();
+		try {
+			const redate = this.db.prepare("UPDATE names SET timestamp = ? WHERE context = ? AND name = ? AND timestamp < ?");
+			this.db.exec("BEGIN");
+			for (const [context, { name, timestamp }] of this.lastName) redate.run(timestamp, context, name, timestamp);
+			this.db.exec("COMMIT");
+		} finally {
+			this.db.close();
+		}
 	}
 	/** Unsigned round-trip check, used by the tests. */
 	cellIdsFor(context) {