signalk-tides 1.1.1 → 1.2.1

package/README.md

@@ -35,79 +35,173 @@ $ curl http://localhost:3000/signalk/v2/api/resources/tides
 
 ```json
 {
-   "id" : "9710441",
-   "name" : "Nurse Channel",
-   "position" : {
-      "latitude" : 22.516666666667,
-      "longitude" : -75.85
-   },
    "extremes" : [
       {
-         "time" : "2025-03-16T01:51:00.000Z",
+         "time" : "2025-03-29T00:45:00.000Z",
+         "type" : "Low",
+         "value" : 0.025
+      },
+      {
+         "time" : "2025-03-29T07:20:00.000Z",
+         "type" : "High",
+         "value" : 1.928
+      },
+      {
+         "time" : "2025-03-29T13:18:00.000Z",
+         "type" : "Low",
+         "value" : 0.044
+      },
+      {
+         "time" : "2025-03-29T19:45:00.000Z",
+         "type" : "High",
+         "value" : 1.815
+      },
+      {
+         "time" : "2025-03-30T01:24:00.000Z",
+         "type" : "Low",
+         "value" : 0.164
+      },
+      {
+         "time" : "2025-03-30T07:52:00.000Z",
+         "type" : "High",
+         "value" : 2.024
+      },
+      {
+         "time" : "2025-03-30T14:05:00.000Z",
+         "type" : "Low",
+         "value" : -0.131
+      },
+      {
+         "time" : "2025-03-30T20:43:00.000Z",
+         "type" : "High",
+         "value" : 1.733
+      },
+      {
+         "time" : "2025-03-31T02:05:00.000Z",
+         "type" : "Low",
+         "value" : 0.334
+      },
+      {
+         "time" : "2025-03-31T08:27:00.000Z",
+         "type" : "High",
+         "value" : 2.084
+      },
+      {
+         "time" : "2025-03-31T14:53:00.000Z",
+         "type" : "Low",
+         "value" : -0.247
+      },
+      {
+         "time" : "2025-03-31T21:44:00.000Z",
+         "type" : "High",
+         "value" : 1.632
+      },
+      {
+         "time" : "2025-04-01T02:48:00.000Z",
+         "type" : "Low",
+         "value" : 0.517
+      },
+      {
+         "time" : "2025-04-01T09:06:00.000Z",
+         "type" : "High",
+         "value" : 2.094
+      },
+      {
+         "time" : "2025-04-01T15:46:00.000Z",
+         "type" : "Low",
+         "value" : -0.29
+      },
+      {
+         "time" : "2025-04-01T22:51:00.000Z",
          "type" : "High",
-         "value" : 0.836
+         "value" : 1.529
       },
       {
-         "time" : "2025-03-16T08:03:00.000Z",
+         "time" : "2025-04-02T03:37:00.000Z",
          "type" : "Low",
-         "value" : -0.016
+         "value" : 0.695
       },
       {
-         "time" : "2025-03-16T14:05:00.000Z",
+         "time" : "2025-04-02T09:49:00.000Z",
          "type" : "High",
-         "value" : 0.77
+         "value" : 2.05
       },
       {
-         "time" : "2025-03-16T20:11:00.000Z",
+         "time" : "2025-04-02T16:43:00.000Z",
          "type" : "Low",
-         "value" : -0.028
+         "value" : -0.263
       },
       {
-         "time" : "2025-03-17T02:26:00.000Z",
+         "time" : "2025-04-03T00:04:00.000Z",
          "type" : "High",
-         "value" : 0.83
+         "value" : 1.448
       },
       {
-         "time" : "2025-03-17T08:40:00.000Z",
+         "time" : "2025-04-03T04:35:00.000Z",
          "type" : "Low",
-         "value" : 0.004
+         "value" : 0.847
       },
       {
-         "time" : "2025-03-17T14:39:00.000Z",
+         "time" : "2025-04-03T10:39:00.000Z",
          "type" : "High",
-         "value" : 0.723
+         "value" : 1.957
       },
       {
-         "time" : "2025-03-17T20:43:00.000Z",
+         "time" : "2025-04-03T17:50:00.000Z",
          "type" : "Low",
-         "value" : -0.01
+         "value" : -0.189
       },
       {
-         "time" : "2025-03-18T03:02:00.000Z",
+         "time" : "2025-04-04T01:24:00.000Z",
          "type" : "High",
-         "value" : 0.813
+         "value" : 1.421
       },
       {
-         "time" : "2025-03-18T09:19:00.000Z",
+         "time" : "2025-04-04T05:49:00.000Z",
          "type" : "Low",
-         "value" : 0.033
+         "value" : 0.946
       },
       {
-         "time" : "2025-03-18T15:15:00.000Z",
+         "time" : "2025-04-04T11:40:00.000Z",
          "type" : "High",
-         "value" : 0.675
+         "value" : 1.837
       },
       {
-         "time" : "2025-03-18T21:16:00.000Z",
+         "time" : "2025-04-04T19:07:00.000Z",
          "type" : "Low",
-         "value" : 0.014
+         "value" : -0.11
+      },
+      {
+         "time" : "2025-04-05T02:40:00.000Z",
+         "type" : "High",
+         "value" : 1.455
+      },
+      {
+         "time" : "2025-04-05T07:19:00.000Z",
+         "type" : "Low",
+         "value" : 0.958
+      },
+      {
+         "time" : "2025-04-05T12:53:00.000Z",
+         "type" : "High",
+         "value" : 1.728
+      },
+      {
+         "time" : "2025-04-05T20:25:00.000Z",
+         "type" : "Low",
+         "value" : -0.061
       }
-   ]
+   ],
+   "station" : {
+      "name" : "Rincon Point, Pier 22 1/2",
+      "position" : {
+         "latitude" : 37.79,
+         "longitude" : -122.387
+      }
+   }
 }
 ```
 
-
-
 ## Sources
 
 - [NOAA](https://tidesandcurrents.noaa.gov/web_services_info.html) (US only)

package/dist/index.js

@@ -0,0 +1,153 @@
+"use strict";
+/*
+ * Copyright 2017 Scott Bender <scott@scottbender.net> and Joachim Bakke
+ * Copyright 2025 Brandon Keepers <brandon@opensoul.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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"));
+module.exports = function (app) {
+    // Interval to update tide data
+    const defaultPeriod = 60; // 1 hour
+    let unsubscribes = [];
+    const sources = [
+        (0, noaa_js_1.default)(app),
+        (0, stormglass_js_1.default)(app),
+        (0, worldtides_js_1.default)(app),
+    ];
+    const plugin = {
+        id: "tides",
+        name: "Tides",
+        // @ts-expect-error: TODO[TS]: fix Plugin type upstream
+        description: "Tidal predictions for the vessel's position from various online sources.",
+        schema: () => ({
+            title: "Tides API",
+            type: "object",
+            properties: {
+                source: {
+                    title: "Data source",
+                    type: "string",
+                    "anyOf": sources.map(({ id, title }) => ({
+                        const: id,
+                        title
+                    })),
+                    default: sources[0].id,
+                },
+                // Update plugin schema with sources
+                ...sources.reduce((properties, source) => Object.assign(properties, source.properties ?? {}), {}),
+                period: {
+                    title: "Update frequency",
+                    type: "number",
+                    description: "How often to update tide data (minutes)",
+                    default: 60,
+                    minimum: 1,
+                },
+            }
+        }),
+        stop() {
+            unsubscribes.forEach((f) => f());
+            unsubscribes = [];
+        }
+    };
+    plugin.start = async function (props) {
+        app.debug("Starting tides-api: " + JSON.stringify(props));
+        // 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
+        const provider = await source.start(props);
+        // Register the source as a resource provider
+        app.registerResourceProvider({
+            type: "tides",
+            methods: {
+                async listResources(query) {
+                    return provider(query);
+                },
+                getResource() {
+                    throw new Error("Not implemented");
+                },
+                setResource() {
+                    throw new Error("Not implemented");
+                },
+                deleteResource() {
+                    throw new Error("Not implemented");
+                }
+            }
+        });
+        app.subscriptionmanager.subscribe({
+            context: "vessels." + app.selfId,
+            subscribe: [
+                {
+                    path: "navigation.position",
+                    period: (props.period ?? defaultPeriod) * 60 * 1000,
+                    policy: "fixed",
+                },
+            ],
+        }, 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") {
+                        performUpdate();
+                    }
+                });
+            });
+        });
+        async function performUpdate() {
+            try {
+                const { extremes } = await provider();
+                // Use server date, or current date if not available
+                const now = new Date(app.getSelfPath("navigation.datetime.value") ?? Date.now());
+                const nextTide = {};
+                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);
+                app.setPluginStatus("Updated tide data");
+            }
+            catch (e) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                app.setPluginError(e.message);
+                // @ts-expect-error: TODO[TS] this accepts more than just a string: https://github.com/bkeepers/signalk-server/blob/d6845ee1f915e6b729d66d2b08b15dc2e0da8e51/src/interfaces/plugins.ts#L517-L519
+                app.error(e);
+            }
+        }
+        // Perform initial update on startup
+        performUpdate();
+    };
+    return plugin;
+};

package/dist/sources/noaa.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 geolib_1 = require("geolib");
+const moment_1 = __importDefault(require("moment"));
+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';
+function default_1(app) {
+    return {
+        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 station = stations.closestTo(position);
+                const endpoint = new URL(dataGetterUrl);
+                endpoint.search = new URLSearchParams({
+                    product: "predictions",
+                    application: "signalk.org/node-server",
+                    begin_date: (0, moment_1.default)(date).format("YYYYMMDD"),
+                    end_date: (0, moment_1.default)(date).add(7, "days").format("YYYYMMDD"),
+                    datum,
+                    station: station.id,
+                    time_zone: "gmt",
+                    units: "metric",
+                    interval: "hilo",
+                    format: "json",
+                }).toString();
+                app.debug(`Fetching tides from NOAA: ${endpoint}`);
+                try {
+                    const res = await fetch(endpoint.toString());
+                    if (!res.ok)
+                        throw new Error("Failed to fetch NOAA tides: " + res.statusText);
+                    const body = await res.json();
+                    app.debug("NOAA response: \n" + JSON.stringify(body, null, 2));
+                    if (body.error)
+                        throw new Error(body.error.message);
+                    return {
+                        station: {
+                            name: station.name,
+                            position: {
+                                latitude: station.lat,
+                                longitude: station.lng,
+                            },
+                        },
+                        extremes: body.predictions.map(({ t, v, type }) => ({
+                            type: type === "H" ? "High" : "Low",
+                            value: Number(v),
+                            time: new Date(`${t}Z`).toISOString(),
+                        })),
+                    };
+                }
+                catch (err) {
+                    app.setPluginError(`Failed to fetch NOAA tides: ${err}`);
+                    // @ts-expect-error: app.error should accept more than just a string
+                    app.error(err);
+                    throw err;
+                }
+            };
+        }
+    };
+}
+;
+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);
+        }
+        catch (e) {
+            app.debug(`NOAA: failed to load cached tide stations: ${e}`);
+            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));
+        }
+        return new this(data.stations);
+    }
+    constructor(data) {
+        super(data.map((station) => [station.id, station]));
+    }
+    closestTo(position) {
+        return this.near(position, 1)[0];
+    }
+    near(position, limit = 10) {
+        const stationsWithDistances = Array.from(this.values()).map((station) => ({
+            ...station,
+            distance: (0, geolib_1.getDistance)(position, { latitude: station.lat, longitude: station.lng })
+        }));
+        return stationsWithDistances.sort((a, b) => a.distance - b.distance).slice(0, limit);
+    }
+}

package/dist/sources/stormglass.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const moment_1 = __importDefault(require("moment"));
+function default_1(app) {
+    return {
+        id: 'stormglass',
+        title: 'StormGlass.io',
+        properties: {
+            stormglassApiKey: {
+                type: 'string',
+                title: 'StormGlass.io API key'
+            }
+        },
+        start({ stormglassApiKey } = {}) {
+            app.debug("Using StormGlass.io API");
+            return async (params = {}) => {
+                const { date = (0, moment_1.default)().subtract(1, "days").toISOString() } = params;
+                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,
+                }).toString();
+                app.debug("Fetching StormGlass.io: " + endPoint.toString());
+                const res = await fetch(endPoint, {
+                    headers: { Authorization: stormglassApiKey ?? '' },
+                });
+                if (!res.ok)
+                    throw new Error('Failed to fetch StormGlass.io: ' + res.statusText);
+                const data = await res.json();
+                app.debug(JSON.stringify(data, null, 2));
+                return {
+                    station: {
+                        name: data.meta.station.name,
+                        position: {
+                            latitude: data.meta.station.lat,
+                            longitude: data.meta.station.lng,
+                        },
+                    },
+                    extremes: data.data.map(({ type, time, height }) => {
+                        return {
+                            type: type === "high" ? "High" : "Low",
+                            value: height,
+                            time: new Date(time).toISOString(),
+                        };
+                    }),
+                };
+            };
+        }
+    };
+}

package/dist/sources/worldtides.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const moment_1 = __importDefault(require("moment"));
+function default_1(app) {
+    return {
+        id: 'WorldTides.info',
+        title: 'worldtides.info',
+        properties: {
+            worldtidesApiKey: {
+                type: 'string',
+                title: 'worldtides.info API key'
+            }
+        },
+        start({ worldtidesApiKey = '' } = {}) {
+            app.debug("Using WorldTides API");
+            return async (params = {}) => {
+                const { 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,
+                }).toString();
+                app.debug("Fetching worldtides: " + endPoint.toString());
+                const res = await fetch(endPoint);
+                if (!res.ok)
+                    throw new Error('Failed to fetch worldtides: ' + res.statusText);
+                const data = await res.json();
+                app.debug(JSON.stringify(data, null, 2));
+                if (data.status != 200)
+                    throw new Error("worldtides data: " + data.error ? data.error : "none");
+                return {
+                    station: {
+                        name: "WorldTides",
+                        position: {
+                            latitude: data.responseLat,
+                            longitude: data.responseLon,
+                        },
+                    },
+                    extremes: data.extremes.map(({ type, dt, height }) => {
+                        return {
+                            type,
+                            value: height,
+                            time: new Date(dt * 1000).toISOString(),
+                        };
+                    }),
+                };
+            };
+        }
+    };
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "signalk-tides",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "Tidal predictions for the vessel's position from various online sources.",
-  "main": "src/index.js",
+  "main": "./dist/index.js",
   "scripts": {
-    "test": "$NODE $npm_package_main"
+    "build": "tsc -b && vite build",
+    "dev": "vite",
+    "lint": "eslint .",
+    "prepare": "npm run build",
+    "preview": "vite preview"
   },
   "keywords": [
+    "signalk-webapp",
     "signalk-node-server-plugin",
     "signalk-category-cloud"
   ],
@@ -24,12 +29,41 @@
   ],
   "license": "Apache-2.0",
   "dependencies": {
+    "@react-hook/resize-observer": "^2.0.2",
+    "@signalk/server-api": "^2.0",
     "geolib": "^3.3.4",
     "moment": "^2.30.1"
   },
+  "devDependencies": {
+    "@eslint/js": "^9.21.0",
+    "@tailwindcss/vite": "^4.1.3",
+    "@types/d3": "^7.4.3",
+    "@types/node": "^22.13.11",
+    "@types/react": "^19.0.12",
+    "@types/react-dom": "^19.0.4",
+    "@types/recharts": "^1.8.29",
+    "@vitejs/plugin-react": "^4.3.4",
+    "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",
+    "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"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bkeepers/signalk-tides.git"
   },
-  "signalk-plugin-enabled-by-default": true
+  "signalk-plugin-enabled-by-default": true,
+  "signalk": {
+    "appIcon": "icon.svg",
+    "displayName": "Tides"
+  }
 }