@signalk/tracks-plugin 3.0.1 → 3.0.3

package/dist/sqliteStore.d.ts

@@ -1,6 +1,8 @@
 import { TrackQuery } from './timeWindow.js';
 import { TrackStore } from './store.js';
 import { Context, Debug, LatLngTuple, TimedPosition, TimedTrackCollection, TimeWindow, TrackCollection, TrackParams } from './types.js';
+export declare class TransactionStateError extends Error {
+}
 export interface SqliteStoreConfig {
     /** Absolute path to the database file, or ':memory:'. */
     file: string;
@@ -102,7 +104,15 @@ export declare class SqliteTrackStore implements TrackStore {
     segments(context: Context, window?: TimeWindow): LatLngTuple[][];
     recordName(context: Context, name: string, timestamp?: number): void;
     nameFor(context: Context): string | undefined;
-    prune(maxAge: number, keep?: Context): void;
+    prune(maxAge: number, keep?: Context, now?: number): void;
+    /** Worker startup snapshot; queries and name lookups must not open a second database. */
+    storedNames(): {
+        context: string;
+        name: string;
+        timestamp: number;
+    }[];
+    /** A failed batch stops writes in its worker; reads remain available. */
+    transaction(write: () => void): void;
     close(): void;
     /** Unsigned round-trip check, used by the tests. */
     cellIdsFor(context: Context): bigint[];

package/dist/store.d.ts

@@ -93,5 +93,5 @@ export interface TrackStore {
      * store holding file handles must implement it and the plugin calls it from
      * `stop()`.
      */
-    close?(): void;
+    close?(): void | Promise<void>;
 }

package/dist/timeWindow.d.ts

@@ -25,9 +25,32 @@ export interface TrackQuery {
  * and the whole retained track is returned, as before.
  */
 export declare function parseTrackQuery(query: Record<string, unknown>, now?: number, alsoAllowed?: readonly string[]): TrackQuery;
+/**
+ * The time between two points that no history bucket either side can account
+ * for.
+ *
+ * Providers disagree on whether a bucket's timestamp marks its start or its
+ * end, so a bucket may cover up to its width on either side of it. Two
+ * buckets, however, cover the time between their timestamps once between
+ * them, so one width is taken off, the wider of the two: exact between
+ * buckets under either convention, and between a fix and a bucket never more
+ * than the pause could be.
+ */
+export declare function uncoveredBetween(previous: TimedPosition, point: TimedPosition): number;
+/**
+ * The pause in the recording between two consecutive points: where thinning
+ * dropped the points between them, the longest pause among those it recorded,
+ * and otherwise whatever of the time between them no bucket accounts for.
+ */
+export declare function pauseBetween(previous: TimedPosition, point: TimedPosition): number;
 /**
  * Drop points closer together than `resolution` milliseconds, always keeping
  * the first and last so the track keeps its extent.
+ *
+ * A point kept after dropped ones records the longest pause among them as
+ * `pauseBefore`: the kept points are further apart than anything recorded
+ * between them, so without it `segment()` would read the spacing thinning
+ * made as a stop in the recording.
  */
 export declare function thin(points: TimedPosition[], resolution: number | undefined): TimedPosition[];
 /**
@@ -57,9 +80,10 @@ export declare function thinToBudget(points: TimedPosition[], maxPoints: number,
  * over an anchorage it actually sat still in.
  *
  * Operates on timestamped points rather than inside a store, so both the
- * in-memory and sqlite stores segment identically, and so it composes with
- * `thin()` — thinning first, then segmenting, keeps a thinned-away gap from
- * being invented as a join.
+ * in-memory and sqlite stores segment identically. A gap is a pause in the
+ * recording, not in the points given: see `pauseBetween`, which lets a
+ * thinned track, or one reconciled with history buckets, segment exactly as
+ * the recording would.
  *
  * `gap` of 0 or undefined returns a single segment, preserving the old shape.
  * An empty input returns no segments rather than one empty one, so a caller can

package/dist/trackStoreProtocol.d.ts

@@ -0,0 +1,38 @@
+import { SqliteTrackStore } from './sqliteStore.js';
+export type StoreMethod = 'newPosition' | 'recordName' | 'initialTrack' | 'prune' | 'get' | 'getTimed' | 'getAllTracks' | 'getFilteredTracks' | 'getFilteredTimedTracks' | 'close';
+export type Operation = {
+    [K in StoreMethod]: {
+        id: number;
+        method: K;
+        args: Parameters<SqliteTrackStore[K]>;
+    };
+}[StoreMethod];
+export interface StoredName {
+    context: string;
+    name: string;
+    timestamp: number;
+}
+export type WorkerMessage = {
+    kind: 'ready';
+    names: StoredName[];
+} | {
+    kind: 'debug';
+    text: string;
+} | {
+    kind: 'fatal';
+    error: string;
+} | {
+    kind: 'result';
+    results: {
+        id: number;
+        value?: unknown;
+        error?: string;
+        writeFailed?: boolean;
+        selfPositionUnavailable?: boolean;
+        name?: {
+            context: string;
+            value: string | undefined;
+        };
+        names?: string[];
+    }[];
+};

package/dist/trackStoreWorker.d.ts

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