signalk-tides 1.3.0 → 1.4.0

package/.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 100
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 100

package/README.md

@@ -18,6 +18,8 @@ It publishes the following [tide data](https://signalk.org/specification/1.7.0/d
 * `environment.tide.timeHigh`
 * `environment.tide.heightLow`
 * `environment.tide.timeLow`
+* `environment.tide.heightNow`
+* `environment.tide.stationName`
 
 ### Tides resource
 

package/dist/cache.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+class FileCache {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    async get(key) {
+        try {
+            const content = await (0, promises_1.readFile)(this.getKey(key), 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    async set(key, value) {
+        // Ensure directory exists
+        await (0, promises_1.mkdir)(this.path, { recursive: true });
+        return (0, promises_1.writeFile)(this.getKey(key), JSON.stringify(value));
+    }
+    getKey(key) {
+        return (0, path_1.join)(this.path, `${key}.json`);
+    }
+}
+exports.default = FileCache;

package/dist/index.js

@@ -21,11 +21,11 @@ const noaa_js_1 = __importDefault(require("./sources/noaa.js"));
 const stormglass_js_1 = __importDefault(require("./sources/stormglass.js"));
 const worldtides_js_1 = __importDefault(require("./sources/worldtides.js"));
 const calculations_js_1 = require("./calculations.js");
+const cache_js_1 = __importDefault(require("./cache.js"));
 module.exports = function (app) {
     // Interval to update tide data
     const defaultPeriod = 60; // 1 hour
     let unsubscribes = [];
-    let lastForecast = null;
     const sources = [
         (0, noaa_js_1.default)(app),
         (0, stormglass_js_1.default)(app),
@@ -67,6 +67,9 @@ module.exports = function (app) {
     };
     plugin.start = async function (props) {
         app.debug("Starting tides-api: " + JSON.stringify(props));
+        let lastForecast = null;
+        let lastPosition = null;
+        const cache = new cache_js_1.default(app.getDataDirPath());
         // Use the selected source, or the first one if not specified
         const source = sources.find(source => source.id === props.source) || sources[0];
         // Load the selected source
@@ -76,7 +79,9 @@ module.exports = function (app) {
             type: "tides",
             methods: {
                 async listResources(query) {
-                    return provider(query);
+                    if (!lastPosition)
+                        throw new Error("No position available");
+                    return provider({ position: lastPosition, ...query });
                 },
                 getResource() {
                     throw new Error("Not implemented");
@@ -100,45 +105,23 @@ module.exports = function (app) {
             ],
         }, unsubscribes, (subscriptionError) => {
             app.error("Error:" + subscriptionError);
-        }, (delta) => {
-            // @ts-expect-error: TODO[TS]: fix Delta type upstream
-            delta.updates.forEach(({ values }) => {
-                // @ts-expect-error: TODO[TS]: fix Delta type upstream
-                values.forEach(({ path }) => {
-                    if (path === "navigation.position") {
-                        updateForecast();
-                    }
-                });
-            });
-        });
-        async function updateForecast(now = new Date()) {
+        }, updatePosition);
+        async function updatePosition() {
+            lastPosition = app.getSelfPath('navigation.position.value') || await cache.get('position') || null;
+            if (lastPosition) {
+                await cache.set('position', lastPosition);
+                await updateForecast();
+            }
+        }
+        async function updateForecast() {
+            if (!lastPosition) {
+                app.debug("No position available, cannot fetch tide data");
+                return;
+            }
             try {
-                lastForecast = await provider();
-                const nextTide = {};
-                lastForecast.extremes.forEach(({ type, value, time }) => {
-                    // Get the first tide of this type after now
-                    if (!nextTide[type] && new Date(time) > now) {
-                        nextTide[type] = { time, value };
-                    }
-                });
-                const delta = {
-                    context: "vessels." + app.selfId,
-                    updates: [
-                        {
-                            timestamp: now.toISOString(),
-                            values: Object.entries(nextTide).flatMap(([type, { time, value }]) => {
-                                return [
-                                    { path: `environment.tide.height${type}`, value: value },
-                                    { path: `environment.tide.time${type}`, value: time },
-                                ];
-                            }),
-                        },
-                    ],
-                };
-                app.debug("Sending delta: " + JSON.stringify(delta));
-                app.handleMessage(plugin.id, delta);
-                updateHeightNow();
-                app.setPluginStatus("Updated tide data");
+                lastForecast = await provider({ position: lastPosition });
+                app.setPluginStatus("Updated tide forecast from " + source.title);
+                updateTides();
             }
             catch (e) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -147,25 +130,42 @@ module.exports = function (app) {
                 app.error(e);
             }
         }
-        async function updateHeightNow(now = new Date()) {
+        async function updateTides(now = new Date()) {
             if (!lastForecast)
                 return;
-            // Combine heights and extremes to account for min/max being between height samples
-            const height = (0, calculations_js_1.approximateTideHeightAt)(lastForecast.extremes, now);
-            app.handleMessage(plugin.id, {
+            // Get the next two upcoming extremes
+            const nextTides = lastForecast.extremes.filter(({ time }) => new Date(time) >= now).slice(0, 2);
+            const delta = {
                 context: "vessels." + app.selfId,
                 updates: [
                     {
                         timestamp: now.toISOString(),
-                        values: [{ path: "environment.tide.heightNow", value: height }]
-                    }
-                ]
-            });
+                        values: [
+                            {
+                                path: "environment.tide.stationName",
+                                value: lastForecast.station.name
+                            },
+                            {
+                                path: "environment.tide.heightNow",
+                                value: (0, calculations_js_1.approximateTideHeightAt)(lastForecast.extremes, now)
+                            },
+                            ...nextTides.flatMap(({ type, time, value }) => {
+                                return [
+                                    { path: `environment.tide.height${type}`, value },
+                                    { path: `environment.tide.time${type}`, value: time },
+                                ];
+                            })
+                        ]
+                    },
+                ],
+            };
+            app.debug("Sending delta: " + JSON.stringify(delta));
+            app.handleMessage(plugin.id, delta);
         }
         // Perform initial update on startup after short delay to allow gnss position to be populated
-        delay(4000).then(() => { updateForecast(); });
-        // Update heightNow every minute
-        setInterval(updateHeightNow, 60 * 1000);
+        delay(4000).then(updatePosition);
+        // Update every minute
+        setInterval(updateTides, 60 * 1000);
     };
     function delay(time) {
         return new Promise((resolve) => setTimeout(resolve, time));

package/dist/sources/noaa.js

@@ -5,9 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
 const path_1 = __importDefault(require("path"));
-const promises_1 = __importDefault(require("fs/promises"));
+const promises_1 = require("fs/promises");
 const geolib_1 = require("geolib");
 const moment_1 = __importDefault(require("moment"));
+const cache_js_1 = __importDefault(require("../cache.js"));
 const stationsUrl = `https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations.json?type=tidepredictions`;
 const dataGetterUrl = 'https://api.tidesandcurrents.noaa.gov/api/prod/datagetter';
 const datum = 'MLLW';
@@ -16,11 +17,12 @@ function default_1(app) {
         id: 'noaa',
         title: 'NOAA (US only)',
         async start() {
-            const stations = await StationList.load(app);
-            return async ({ date } = {}) => {
-                const position = app.getSelfPath("navigation.position.value");
-                if (!position)
-                    throw new Error("no position");
+            const cache = new cache_js_1.default(path_1.default.join(app.getDataDirPath(), 'noaa'));
+            const stations = await StationList.load(cache, app);
+            // Remove old cache file
+            (0, promises_1.unlink)(path_1.default.join(app.config.configPath, 'noaastations.json')).catch(() => { });
+            return async (params) => {
+                const { position, date = (0, moment_1.default)().subtract(1, "days") } = params;
                 const station = stations.closestTo(position);
                 const endpoint = new URL(dataGetterUrl);
                 endpoint.search = new URLSearchParams({
@@ -71,21 +73,18 @@ function default_1(app) {
 }
 ;
 class StationList extends Map {
-    static async load(app) {
-        const filename = path_1.default.join(app.config.configPath, "noaastations.json");
-        let data;
-        try {
-            data = JSON.parse(await promises_1.default.readFile(filename, 'utf-8'));
-            app.debug("NOAA: Loaded cached tide stations from " + filename);
+    static async load(cache, app) {
+        let data = await cache.get('stations');
+        if (data) {
+            app.debug("NOAA: Loaded cached tide stations");
         }
-        catch (e) {
-            app.debug(`NOAA: failed to load cached tide stations: ${e}`);
+        else {
             app.debug('NOAA: Downloading tide stations');
             const res = await fetch(stationsUrl);
             if (!res.ok)
                 throw new Error(`Failed to download stations: ${res.statusText}`);
             data = await res.json();
-            await promises_1.default.writeFile(filename, JSON.stringify(data));
+            await cache.set('stations', data);
         }
         return new this(data.stations);
     }

package/dist/sources/stormglass.js

@@ -17,18 +17,14 @@ function default_1(app) {
         },
         start({ stormglassApiKey } = {}) {
             app.debug("Using StormGlass.io API");
-            return async (params = {}) => {
-                const { date = (0, moment_1.default)().subtract(1, "days").toISOString() } = params;
+            return async ({ position, date = (0, moment_1.default)().subtract(1, "days").toISOString() }) => {
                 const endPoint = new URL("https://api.stormglass.io/v2/tide/extremes/point");
-                const position = app.getSelfPath("navigation.position.value");
-                if (!position)
-                    throw new Error("no position");
                 endPoint.search = new URLSearchParams({
                     start: (0, moment_1.default)(date).format("YYYY-MM-DD"),
                     end: (0, moment_1.default)(date).add(7, "days").format("YYYY-MM-DD"),
                     // datum: "CD",
-                    lat: position.latitude,
-                    lng: position.longitude,
+                    lat: position.latitude.toString(),
+                    lng: position.longitude.toString()
                 }).toString();
                 app.debug("Fetching StormGlass.io: " + endPoint.toString());
                 const res = await fetch(endPoint, {
@@ -40,7 +36,7 @@ function default_1(app) {
                 app.debug(JSON.stringify(data, null, 2));
                 return {
                     station: {
-                        name: data.meta.station.name,
+                        name: `${data.meta.station.name} (${data.meta.station.source})`,
                         position: {
                             latitude: data.meta.station.lat,
                             longitude: data.meta.station.lng,

package/dist/sources/worldtides.js

@@ -17,20 +17,17 @@ function default_1(app) {
         },
         start({ worldtidesApiKey = '' } = {}) {
             app.debug("Using WorldTides API");
-            return async (params = {}) => {
-                const { date = (0, moment_1.default)().subtract(1, "days") } = params;
+            return async (params) => {
+                const { position, date = (0, moment_1.default)().subtract(1, "days") } = params;
                 const endPoint = new URL("https://www.worldtides.info/api/v3");
-                const position = app.getSelfPath("navigation.position.value");
-                if (!position)
-                    throw new Error("no position");
                 endPoint.search = new URLSearchParams({
                     date: (0, moment_1.default)(date).format("YYYY-MM-DD"),
                     datum: "CD",
                     days: "7",
                     extremes: "true",
                     key: worldtidesApiKey,
-                    lat: position.latitude,
-                    lon: position.longitude,
+                    lat: position.latitude.toString(),
+                    lon: position.longitude.toString(),
                 }).toString();
                 app.debug("Fetching worldtides: " + endPoint.toString());
                 const res = await fetch(endPoint);
@@ -42,7 +39,7 @@ function default_1(app) {
                     throw new Error("worldtides data: " + data.error ? data.error : "none");
                 return {
                     station: {
-                        name: "WorldTides",
+                        name: `${data.station} (${data.atlas})`,
                         position: {
                             latitude: data.responseLat,
                             longitude: data.responseLon,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-tides",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Tidal predictions for the vessel's position from various online sources.",
   "main": "./dist/index.js",
   "scripts": {
@@ -38,24 +38,22 @@
     "@eslint/js": "^9.21.0",
     "@tailwindcss/vite": "^4.1.3",
     "@types/d3": "^7.4.3",
-    "@types/node": "^22.13.11",
+    "@types/node": "^24.3.1",
     "@types/react": "^19.0.12",
     "@types/react-dom": "^19.0.4",
-    "@types/recharts": "^1.8.29",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@vitejs/plugin-react": "^5.0.2",
     "d3": "^7.9.0",
     "eslint": "^9.21.0",
     "eslint-plugin-react-hooks": "^5.1.0",
     "eslint-plugin-react-refresh": "^0.4.19",
-    "globals": "^15.15.0",
+    "globals": "^16.3.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
-    "recharts": "^2.15.1",
     "signalk-server": "^2.13.5",
     "tailwindcss": "^4.1.3",
     "typescript": "^5.8.2",
     "typescript-eslint": "^8.24.1",
-    "vite": "^6.2.0"
+    "vite": "^7.1.5"
   },
   "repository": {
     "type": "git",