signalk-siparu 0.2.17 → 0.2.18

package/NOTICE

@@ -40,3 +40,22 @@ Map data and assets served from the tile host (not bundled in this package):
   OpenStreetMap contributors - ODbL 1.0 - https://www.openstreetmap.org/copyright
   Protomaps basemaps       - BSD-3-Clause - https://github.com/protomaps/basemaps
   Noto Sans glyphs         - SIL OFL 1.1  - https://github.com/protomaps/basemaps-assets
+
+-------------------------------------------------------------------------------
+GeoNames gazetteer - https://www.geonames.org
+Creative Commons Attribution 4.0 - https://creativecommons.org/licenses/by/4.0/
+
+  plugin/data/places.json.gz is an extract of coastal places (harbours, bays and the
+  towns behind them) from the GeoNames dump, built by tools/build-places.mjs. The
+  plugin uses it aboard to name where a voyage began and ended.
+  Current file: built 2026-10-06 from the GeoNames dump of 2026-10-06 and the World
+  Port Index as published on 2026-10-06;
+  sha256 7ed46496ab48dde6ed2d6b07878cb7404f659aeb16475ea4e06a96993dc4ac72.
+
+-------------------------------------------------------------------------------
+World Port Index (Publication 150) - https://msi.nga.mil
+National Geospatial-Intelligence Agency, United States. A work of the US government,
+in the public domain.
+
+  Port names and positions from the index are folded into plugin/data/places.json.gz
+  where GeoNames does not carry the port under the same name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-siparu",
-  "version": "0.2.17",
+  "version": "0.2.18",
   "description": "Kept aboard, proven ashore. Position, wind, depth and voyage history, recorded on the boat and readable from anywhere: sealed to the devices you name, signed on the way out. A read-only Signal K plugin with a built-in dashboard.",
   "keywords": [
     "signalk-node-server-plugin",
@@ -9,6 +9,7 @@
   "main": "plugin/dist/index.js",
   "files": [
     "plugin/dist",
+    "plugin/data",
     "public",
     "NOTICE"
   ],

package/plugin/dist/index.js

@@ -60,6 +60,7 @@ const approval_1 = require("./approval");
 const keystore_1 = require("./keystore");
 const keysync_1 = require("./keysync");
 const sealer_1 = require("./sealer");
+const places_1 = require("./places");
 const voyagelog_1 = require("./voyagelog");
 const phaselog_1 = require("./phaselog");
 const PLUGIN_ID = 'siparu';
@@ -303,7 +304,7 @@ module.exports = (app) => {
             rollups = ru;
             const qs = new query_1.QueryService(st, ru);
             query = qs;
-            const vl = new voyagelog_1.VoyageLog(st, opts, (msg) => app.debug(msg));
+            const vl = new voyagelog_1.VoyageLog(st, opts, (msg) => app.debug(msg), places_1.Gazetteer.lazy(places_1.PLACES_FILE, (msg) => app.debug(msg)));
             voyages = vl;
             const pl = new phaselog_1.PhaseLog(st, opts, (msg) => app.debug(msg));
             phases = pl;

package/plugin/dist/places.d.ts

@@ -0,0 +1,19 @@
+export type PlaceResolver = (lat: number | null, lon: number | null) => string | null;
+export declare const PLACES_FILE: string;
+export declare const PLACE_RADIUS_NM = 5;
+export declare const WATER_HANDICAP_NM = 1;
+export declare const HAMLET_HANDICAP_NM = 0.75;
+export declare class Gazetteer {
+    private readonly lat;
+    private readonly lon;
+    private readonly kind;
+    private readonly names;
+    private constructor();
+    static parse(text: string): Gazetteer;
+    static fromFile(file: string, log?: (msg: string) => void): Gazetteer | null;
+    static lazy(file: string, log?: (msg: string) => void, withinNm?: number): PlaceResolver;
+    get size(): number;
+    nearest(lat: number, lon: number, withinNm?: number): string | null;
+    private firstAtOrAbove;
+    resolver(withinNm?: number): PlaceResolver;
+}

package/plugin/dist/places.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gazetteer = exports.HAMLET_HANDICAP_NM = exports.WATER_HANDICAP_NM = exports.PLACE_RADIUS_NM = exports.PLACES_FILE = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_zlib_1 = require("node:zlib");
+const rollup_1 = require("./rollup");
+const LAND = 0;
+const WATER = 1;
+const HAMLET = 2;
+exports.PLACES_FILE = path.join(__dirname, '..', 'data', 'places.json.gz');
+exports.PLACE_RADIUS_NM = 5;
+exports.WATER_HANDICAP_NM = 1;
+exports.HAMLET_HANDICAP_NM = 0.75;
+function isRow(x) {
+    return (Array.isArray(x) &&
+        (x.length === 3 || (x.length === 4 && (x[3] === LAND || x[3] === WATER || x[3] === HAMLET))) &&
+        typeof x[0] === 'number' &&
+        typeof x[1] === 'number' &&
+        typeof x[2] === 'string' &&
+        x[0] >= -90 &&
+        x[0] <= 90 &&
+        x[1] >= -180 &&
+        x[1] <= 180 &&
+        x[2].length > 0);
+}
+class Gazetteer {
+    lat;
+    lon;
+    kind;
+    names;
+    constructor(lat, lon, kind, names) {
+        this.lat = lat;
+        this.lon = lon;
+        this.kind = kind;
+        this.names = names;
+    }
+    static parse(text) {
+        const parsed = JSON.parse(text);
+        const rows = Array.isArray(parsed.places) ? parsed.places.filter(isRow) : [];
+        rows.sort((a, b) => a[0] - b[0]);
+        const lat = new Float64Array(rows.length);
+        const lon = new Float64Array(rows.length);
+        const kind = new Uint8Array(rows.length);
+        const names = new Array(rows.length);
+        rows.forEach((r, i) => {
+            lat[i] = r[0];
+            lon[i] = r[1];
+            kind[i] = r[3] ?? 0;
+            names[i] = r[2];
+        });
+        return new Gazetteer(lat, lon, kind, names);
+    }
+    static fromFile(file, log) {
+        try {
+            const bytes = fs.readFileSync(file);
+            const text = bytes[0] === 0x1f && bytes[1] === 0x8b ? (0, node_zlib_1.gunzipSync)(bytes).toString('utf8') : bytes.toString('utf8');
+            const g = Gazetteer.parse(text);
+            if (g.size === 0) {
+                log?.(`places: ${file} holds no places; voyage ends stay positions`);
+                return null;
+            }
+            log?.(`places: ${g.size} places loaded from ${file}`);
+            return g;
+        }
+        catch (err) {
+            log?.(`places: gazetteer not loaded from ${file}: ${err}`);
+            return null;
+        }
+    }
+    static lazy(file, log, withinNm = exports.PLACE_RADIUS_NM) {
+        let loaded;
+        return (lat, lon) => {
+            if (lat === null || lon === null)
+                return null;
+            if (loaded === undefined)
+                loaded = Gazetteer.fromFile(file, log);
+            return loaded ? loaded.nearest(lat, lon, withinNm) : null;
+        };
+    }
+    get size() {
+        return this.names.length;
+    }
+    nearest(lat, lon, withinNm = exports.PLACE_RADIUS_NM) {
+        const band = withinNm / 60;
+        const cosLat = Math.cos((lat * Math.PI) / 180);
+        const lonBand = cosLat > 1e-6 ? band / cosLat : 360;
+        let best = null;
+        let bestScore = Infinity;
+        for (let i = this.firstAtOrAbove(lat - band); i < this.names.length; i++) {
+            const rowLat = this.lat[i];
+            if (rowLat > lat + band)
+                break;
+            const rowLon = this.lon[i];
+            let dLon = Math.abs(rowLon - lon);
+            if (dLon > 180)
+                dLon = 360 - dLon;
+            if (dLon > lonBand)
+                continue;
+            const d = (0, rollup_1.haversineNm)(lat, lon, rowLat, rowLon);
+            if (d >= withinNm)
+                continue;
+            const k = this.kind[i];
+            const score = k === WATER ? d + exports.WATER_HANDICAP_NM : k === HAMLET ? d + exports.HAMLET_HANDICAP_NM : d;
+            if (score < bestScore) {
+                bestScore = score;
+                best = this.names[i];
+            }
+        }
+        return best;
+    }
+    firstAtOrAbove(lat) {
+        let lo = 0;
+        let hi = this.lat.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (this.lat[mid] < lat)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return lo;
+    }
+    resolver(withinNm = exports.PLACE_RADIUS_NM) {
+        return (lat, lon) => (lat === null || lon === null ? null : this.nearest(lat, lon, withinNm));
+    }
+}
+exports.Gazetteer = Gazetteer;

package/plugin/dist/voyagelog.d.ts

@@ -1,6 +1,7 @@
 import { Snapshot, TrackPoint, Voyage, VoyageStatsResult } from './contract';
 import { Options } from './config';
 import { RollupEngine } from './rollup';
+import { PlaceResolver } from './places';
 import { Logger, Store } from './store';
 export type EditResult = {
     ok: true;
@@ -13,13 +14,15 @@ export declare class VoyageLog {
     private store;
     private opts;
     private log;
+    private place;
     private state;
     private manual;
     private window;
     private chain;
     private persistedRevision;
     private filePath;
-    constructor(store: Store, opts: Options, log: Logger);
+    constructor(store: Store, opts: Options, log: Logger, place?: PlaceResolver);
+    private named;
     private enqueue;
     init(now: number): Promise<void>;
     feed(snap: Snapshot): Promise<void>;

package/plugin/dist/voyagelog.js

@@ -45,18 +45,29 @@ class VoyageLog {
     store;
     opts;
     log;
+    place;
     state = { voyages: [], nextId: 1 };
     manual = [];
     window = [];
     chain = Promise.resolve();
     persistedRevision = '';
     filePath;
-    constructor(store, opts, log) {
+    constructor(store, opts, log, place = () => null) {
         this.store = store;
         this.opts = opts;
         this.log = log;
+        this.place = place;
         this.filePath = path.join(store.rollupDir, 'voyages.json');
     }
+    named(v) {
+        const start_port = v.start_port ?? (0, voyage_1.nearestPort)(v.start_lat, v.start_lon, this.opts.ports) ?? this.place(v.start_lat, v.start_lon);
+        const end_port = v.status === 'closed'
+            ? (v.end_port ?? (0, voyage_1.nearestPort)(v.end_lat, v.end_lon, this.opts.ports) ?? this.place(v.end_lat, v.end_lon))
+            : v.end_port;
+        if (start_port === v.start_port && end_port === v.end_port)
+            return v;
+        return { ...v, start_port, end_port };
+    }
     enqueue(job) {
         const run = this.chain.then(job);
         this.chain = run.then(() => undefined, (err) => this.log(`voyage error: ${err}`));
@@ -94,10 +105,14 @@ class VoyageLog {
         });
     }
     list(limit) {
-        return [...this.state.voyages].sort((a, b) => b.start_ts - a.start_ts).slice(0, limit);
+        return [...this.state.voyages]
+            .sort((a, b) => b.start_ts - a.start_ts)
+            .slice(0, limit)
+            .map((v) => this.named(v));
     }
     current() {
-        return this.state.voyages.find((v) => v.status === 'open') ?? null;
+        const open = this.state.voyages.find((v) => v.status === 'open');
+        return open ? this.named(open) : null;
     }
     async track(voyageId, now) {
         const v = this.state.voyages.find((x) => x.id === voyageId);