signalk-tides 2.0.0-beta.1 → 2.1.0

package/.github/workflows/ci.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Setup Node.js
         uses: actions/setup-node@v6
@@ -27,7 +27,7 @@ jobs:
       CI: true
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Setup Node.js
         uses: actions/setup-node@v6
@@ -51,7 +51,7 @@ jobs:
       id-token: write
       pull-requests: write
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - uses: actions/setup-node@v6
 

package/.github/workflows/release.yml

@@ -0,0 +1,41 @@
+name: Release
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write # npm trusted publishing
+      contents: write # commit the version bump
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.event.release.target_commitish }}
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24 # npm >= 11.5.1 for trusted publishing
+          registry-url: https://registry.npmjs.org
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Set version to release tag
+        run: npm version "${TAG#v}" --no-git-tag-version --allow-same-version
+        env:
+          TAG: ${{ github.event.release.tag_name }}
+
+      - name: Publish to npm
+        run: npm publish # prepack runs the build
+
+      # Only after a successful publish, so a failed release never mutates the repo
+      - name: Commit version bump
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git diff --quiet || { git commit -am "Release ${TAG#v}" && git push; }
+        env:
+          TAG: ${{ github.event.release.tag_name }}

package/README.md

@@ -26,10 +26,10 @@ It publishes the following [tide data](https://signalk.org/specification/1.7.0/d
 
 ### Tides API
 
-The plugin mounts the [Neaps API](https://github.com/neaps/neaps) at `/signalk/v2/api/tides`, which serves station search, extremes, and timeline predictions. The synthetic station `vessel/current` resolves to the nearest station to the vessel:
+The plugin mounts the [Neaps API](https://github.com/neaps/neaps) at `/signalk/v2/api/tides`, which serves station search, extremes, and timeline predictions. The synthetic station `vessel/default` resolves to the configured default station, or the nearest station to the vessel when none is set:
 
 ```
-$ curl http://localhost:3000/signalk/v2/api/tides/stations/vessel/current/extremes
+$ curl http://localhost:3000/signalk/v2/api/tides/stations/vessel/default/extremes
 ```
 
 ### Tides resource

package/dist/index.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { createRoutes } from "@neaps/api";
-import { getExtremesPrediction, getWaterLevelAtTime } from "neaps";
+import { findStation, nearestStation, stationsNear } from "neaps";
 import { tideStateAt, timeToNextExtreme } from "./calculations.js";
 import FileCache from "./cache.js";
 import { withVesselPosition } from "./middleware.js";
@@ -25,6 +25,8 @@ const API_PATH = "/signalk/v2/api/tides";
 export default function (app) {
     let unsubscribes = [];
     let activeRouter = null;
+    let lastPosition = null;
+    let config = {};
     // Mount forwarding middleware once (Express doesn't support unmounting)
     // @ts-expect-error: app is an Express app at runtime
     app.use(API_PATH, (req, res, next) => {
@@ -42,7 +44,15 @@ export default function (app) {
         schema: () => ({
             title: "Tides",
             type: "object",
-            properties: {},
+            properties: {
+                defaultStation: {
+                    type: "string",
+                    title: "Default tide station",
+                    description: "Use the closest station to the vessel's current position, or pick a default nearby station.",
+                    default: "auto",
+                    oneOf: defaultStationOptions(),
+                },
+            },
         }),
         start,
         stop() {
@@ -51,21 +61,59 @@ export default function (app) {
             activeRouter = null;
         },
     };
-    async function start() {
+    function defaultStationOptions() {
+        const options = [{ const: "auto", title: "Closest station" }];
+        if (lastPosition) {
+            for (const station of stationsNear({ ...lastPosition, maxResults: 10 })) {
+                options.push({ const: station.id, title: stationTitle(station) });
+            }
+        }
+        // Keep the saved station selectable even when it is not in the nearby
+        // list, so opening the settings far from it (or before a position fix)
+        // cannot clobber it on save.
+        const saved = savedDefaultStation();
+        if (saved && saved !== "auto" && !options.some((o) => o.const === saved)) {
+            let title = saved;
+            try {
+                title = stationTitle(findStation(saved));
+            }
+            catch {
+                // Unknown id: keep the raw value as the label
+            }
+            options.splice(1, 0, { const: saved, title });
+        }
+        return options;
+    }
+    function savedDefaultStation() {
+        try {
+            const saved = app.readPluginOptions();
+            return saved?.configuration?.defaultStation;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async function start(options) {
         app.debug("Starting tides");
+        config = (options ?? {});
+        // Keep the forecast and the predictor that produced it together, so the
+        // extremes and the current height are always read from the same station.
         let lastForecast = null;
-        let lastPosition = null;
+        let lastPredictor = null;
         const cache = new FileCache(app.getDataDirPath());
-        // Mount the Neaps API, with vessel/current resolved to the nearest station.
-        activeRouter = withVesselPosition(createRoutes({ prefix: API_PATH }), () => lastPosition);
+        // Mount the Neaps API, with vessel/default resolved to the configured
+        // default station (or the nearest one).
+        activeRouter = withVesselPosition(createRoutes({ prefix: API_PATH }), () => lastPosition, () => config.defaultStation ?? null);
         // Register tide predictions as a resource provider
         app.registerResourceProvider({
             type: "tides",
             methods: {
                 async listResources() {
-                    if (!lastPosition)
-                        throw new Error("No position available");
-                    return forecastFor(lastPosition);
+                    const predictor = resolvePredictor();
+                    if (!predictor) {
+                        throw new Error("No position or default station available");
+                    }
+                    return forecastFor(predictor);
                 },
                 getResource() {
                     throw new Error("Not implemented");
@@ -90,11 +138,28 @@ export default function (app) {
         }, unsubscribes, (subscriptionError) => {
             app.error("Error:" + subscriptionError);
         }, updatePosition);
-        function forecastFor(position) {
+        function resolvePredictor() {
+            if (config.defaultStation && config.defaultStation !== "auto") {
+                try {
+                    return findStation(config.defaultStation);
+                }
+                catch {
+                    app.error(`Configured tide station not found: ${config.defaultStation}`);
+                }
+            }
+            if (lastPosition) {
+                try {
+                    return nearestStation(lastPosition);
+                }
+                catch {
+                    app.error("No tide station found near vessel position");
+                }
+            }
+            return null;
+        }
+        function forecastFor(predictor) {
             const now = new Date();
-            return getExtremesPrediction({
-                latitude: position.latitude,
-                longitude: position.longitude,
+            return predictor.getExtremesPrediction({
                 start: now,
                 end: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000),
             });
@@ -110,16 +175,20 @@ export default function (app) {
             if (!lastPosition) {
                 lastPosition = (await cache.get("position"));
             }
-            if (lastPosition)
-                updateForecast();
+            // A configured default station predicts without a position
+            updateForecast();
         }
         function updateForecast() {
-            if (!lastPosition) {
-                app.debug("No position available, cannot compute tide data");
+            const predictor = resolvePredictor();
+            if (!predictor) {
+                app.debug("No position or default station available, cannot compute tide data");
+                lastForecast = null;
+                lastPredictor = null;
                 return;
             }
             try {
-                lastForecast = forecastFor(lastPosition);
+                lastForecast = forecastFor(predictor);
+                lastPredictor = predictor;
                 app.setPluginStatus("Updated tide forecast");
                 updateTides();
             }
@@ -131,17 +200,13 @@ export default function (app) {
             }
         }
         function updateTides(now = new Date()) {
-            if (!lastForecast || !lastPosition)
+            if (!lastForecast || !lastPredictor)
                 return;
             // Get the next two upcoming extremes
             const nextTides = lastForecast.extremes
                 .filter(({ time }) => time >= now)
                 .slice(0, 2);
-            const heightNow = getWaterLevelAtTime({
-                latitude: lastPosition.latitude,
-                longitude: lastPosition.longitude,
-                time: now,
-            }).level;
+            const heightNow = lastPredictor.getWaterLevelAtTime({ time: now }).level;
             const state = tideStateAt(lastForecast.extremes, now);
             const secondsToNextExtreme = timeToNextExtreme(lastForecast.extremes, now);
             const delta = {
@@ -164,7 +229,12 @@ export default function (app) {
                                 ? [{ path: "environment.tide.state", value: state }]
                                 : []),
                             ...(secondsToNextExtreme !== null
-                                ? [{ path: "environment.tide.timeToNextExtreme", value: secondsToNextExtreme }]
+                                ? [
+                                    {
+                                        path: "environment.tide.timeToNextExtreme",
+                                        value: secondsToNextExtreme,
+                                    },
+                                ]
                                 : []),
                             ...nextTides.flatMap(({ label, time, level }) => {
                                 return [
@@ -185,11 +255,16 @@ export default function (app) {
                         meta: [
                             {
                                 path: "environment.tide.state",
-                                value: { description: "Tide trend at the current position: rising or falling" },
+                                value: {
+                                    description: "Tide trend at the current position: rising or falling",
+                                },
                             },
                             {
                                 path: "environment.tide.timeToNextExtreme",
-                                value: { units: "s", description: "Seconds until the next tide extreme (high or low water)" },
+                                value: {
+                                    units: "s",
+                                    description: "Seconds until the next tide extreme (high or low water)",
+                                },
                             },
                         ],
                     },
@@ -209,3 +284,8 @@ export default function (app) {
     }
     return plugin;
 }
+function stationTitle(station) {
+    const where = [station.region, station.country].filter(Boolean).join(", ");
+    const distance = station.distance != null ? ` — ${station.distance.toFixed(1)} km` : "";
+    return `${station.name}${where ? ` (${where})` : ""}${distance}`;
+}

package/dist/middleware.js

@@ -1,33 +1,46 @@
-import { nearestStation } from 'neaps';
+import { findStation, nearestStation } from "neaps";
 /**
- * Middleware that handles vessel/current station endpoints by redirecting to
- * the nearest real station, and injects the default vessel position for
- * location-based queries.
+ * Middleware that resolves the vessel/default station alias and bare
+ * location-based queries (/extremes, /timeline) against the configured default
+ * station, falling back to the station nearest the vessel's position when no
+ * default is set.
  */
-export function withVesselPosition(router, getPosition) {
+export function withVesselPosition(router, getPosition, getDefaultStationId) {
     return (req, res, next) => {
-        const isVesselCurrentPath = /^\/stations\/vessel\/current(?:\/|$)/.test(req.path);
-        // Handle vessel/current station endpoints by redirecting to the nearest real station
-        if (isVesselCurrentPath) {
+        // HTTP 303 See Other: the response can be found under a different URI
+        const redirect = (toPath) => res.redirect(303, `${req.baseUrl}${toPath}`);
+        // The configured default station, or null when unset, "auto", or stale.
+        const defaultStation = () => {
+            const id = getDefaultStationId?.();
+            if (!id || id === "auto")
+                return null;
+            try {
+                return findStation(id);
+            }
+            catch {
+                return null; // stale or invalid saved id: fall back to position
+            }
+        };
+        // Redirect the vessel/default alias to the configured (or nearest) station.
+        if (/^\/stations\/vessel\/default(?:\/|$)/.test(req.path)) {
+            const toStation = (station) => redirect(req.url.replace(/^\/stations\/vessel\/default\b/, `/stations/${station.id}`));
+            // A configured default station resolves without a position
+            const station = defaultStation();
+            if (station)
+                return toStation(station);
             const pos = getPosition();
             if (!pos) {
-                return res.status(503).json({
-                    message: "Vessel position not available",
-                });
+                return res.status(503).json({ message: "Vessel position not available" });
             }
             try {
-                const station = nearestStation({
+                const nearest = nearestStation({
                     latitude: pos.latitude,
                     longitude: pos.longitude,
                 });
-                if (!station) {
-                    return res.status(404).json({
-                        message: "No nearby stations found",
-                    });
+                if (!nearest) {
+                    return res.status(404).json({ message: "No nearby stations found" });
                 }
-                const path = req.url.replace(/^\/stations\/vessel\/current\b/, `/stations/${station.id}`);
-                // HTTP 303 See Other: the response can be found under a different URI
-                return res.redirect(303, `${req.baseUrl}${path}`);
+                return toStation(nearest);
             }
             catch {
                 return res.status(500).json({
@@ -35,13 +48,29 @@ export function withVesselPosition(router, getPosition) {
                 });
             }
         }
-        // Inject default position for location-based queries
+        // Bare location-based queries: redirect to the configured station when set,
+        // otherwise inject the vessel position so neaps uses the nearest station.
         const isLocationQueryPath = req.path === "/extremes" || req.path === "/timeline";
         if (isLocationQueryPath && !req.query.latitude && !req.query.longitude) {
+            const station = defaultStation();
+            if (station) {
+                return redirect(req.url.replace(/^\/(extremes|timeline)\b/, `/stations/${station.id}/$1`));
+            }
             const pos = getPosition();
             if (pos) {
-                req.query.latitude = String(pos.latitude);
-                req.query.longitude = String(pos.longitude);
+                // Express 5 makes `req.query` a read-only getter, so assigning to its
+                // properties is silently lost. Shadow it with an own data property,
+                // which behaves identically on Express 4 and 5.
+                Object.defineProperty(req, "query", {
+                    value: {
+                        ...req.query,
+                        latitude: String(pos.latitude),
+                        longitude: String(pos.longitude),
+                    },
+                    writable: true,
+                    configurable: true,
+                    enumerable: true,
+                });
             }
         }
         router(req, res, next);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-tides",
-  "version": "2.0.0-beta.1",
+  "version": "2.1.0",
   "description": "Tidal predictions for the vessel's position, powered by Neaps.",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,11 +34,11 @@
   ],
   "license": "Apache-2.0",
   "dependencies": {
-    "@neaps/api": "https://pkg.pr.new/openwatersio/neaps/@neaps/api@4eed5db",
-    "@neaps/react": "https://pkg.pr.new/openwatersio/neaps/@neaps/react@4eed5db",
-    "@signalk/server-api": "^2.0",
-    "express": "^4.0",
-    "neaps": "https://pkg.pr.new/openwatersio/neaps@4eed5db",
+    "@neaps/api": "^0.6.0",
+    "@neaps/react": "^0.1.1",
+    "@signalk/server-api": "^2.28.0",
+    "express": "^5.2.1",
+    "neaps": "^0.7.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0"
   },
@@ -48,8 +48,8 @@
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
-    "@types/express": "^4.0",
-    "@types/node": "^25.0.3",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.0.1",
     "@types/react": "^19.0.12",
     "@types/react-dom": "^19.0.4",
     "@types/supertest": "^7.2.0",
@@ -76,7 +76,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bkeepers/signalk-tides.git"
+    "url": "git+https://github.com/openwatersio/signalk-tides.git"
   },
   "signalk-plugin-enabled-by-default": true,
   "signalk": {