@signalk/freeboard-sk 2.6.0-rc2 → 2.6.0

package/CHANGELOG.md

@@ -2,8 +2,10 @@
 
 ### v2.6.0
 
-- **Added**: Ability to show/hide toolbar buttons on both sides of the screen.
+- **Added**: Ability to show / hide toolbar buttons on both sides of the screen.
 - **Added**: Route builder. 1st release allows creating a route from waypoints.
+- **Added**: Support for displaying S57 vector charts converted using [s57-tiler](https://github.com/wdantuma/s57-tiler).
+- **Updated**: Resources created outside of Freeboard UI (plugins, etc.) are now selected for display on the map. Previously these had to be manually selected from the relevant list.
 - **Fixed**: Wind speed values in vessel popover showing 0 rather than - when no value is present.
 
 ### v2.5.0

package/README.md

@@ -32,6 +32,7 @@ Charts are sourced from the `/resources/charts` path on the Signal K server and
 
 - Image tiles _(XYZ)_
 - Vector Tiles _(MVT / PBF)_
+- [S57 ENC's converted to vector tiles](#S57-charts) _(MVT / PBF)_
 - WMS _(Web Map Server)_
 - WMTS _(Web Map Tile Server)_
 - PMTiles _(ProtoMap files)_
@@ -116,6 +117,27 @@ _Note: The `Signal K Instrument Panel` app will be displayed if no user selectio
 
 ---
 
+### S57 Charts
+
+Freeboard-SK is able to display S57 ENC charts that have been converted to vector tiles with [s57-tiler](https://github.com/wdantuma/s57-tiler). _(See the [README](https://github.com/wdantuma/s57-tiler) for instructions how to create the vectortiles from downloaded S57 ENC's.)_
+
+See [Open CPN chart sources](https://opencpn.org/OpenCPN/info/chartsource.html) for a list of locations to source charts.
+
+_Note: Only unencrypted ENC's are supported (no S63 support)._
+
+**_Requires: @signalk/charts-plugin_**
+
+
+![S57 chart](https://github.com/SignalK/freeboard-sk/assets/38519157/a93b3889-d1c8-4df7-9f6f-97a1666fbf77)
+
+Rendering of the Shallow, safety and deep depths and   can be configured in the settings dialog
+
+![S57 Settings](https://github.com/SignalK/freeboard-sk/assets/38519157/0409492b-1ee7-4905-b5b0-e5fc8e68bc9a)
+
+_Note:  This functionality is not a replacement for official navigational charts_
+
+---
+
 ### Experiments: 
 
 Features that are not ready for "prime time" are made available as experiments.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalk/freeboard-sk",
-  "version": "2.6.0-rc2",
+  "version": "2.6.0",
   "description": "Openlayers chart plotter implementation for Signal K",
   "keywords": [
     "signalk-webapp",

package/plugin/anchor/anchor-api.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAnchorApi = void 0;
+const fetch_1 = require("../lib/fetch");
+let server;
+let hostPath;
+const apiBasePath = '/signalk/v2/api/vessels/self/navigation/anchor';
+const anchorPlugin = {
+    has: false,
+    enabled: false,
+    version: ''
+};
+let pluginPath;
+const msgPluginNotFound = 'signalk-anchor-alarm is not installed!';
+const initAnchorApi = async (app) => {
+    server = app;
+    server.debug(`** initAnchorApi() **`);
+    // detect signalk-anchor-alarm plugin
+    anchorPlugin.has = true;
+    try {
+        let port = 3000;
+        if (typeof server.config?.getExternalPort === 'function') {
+            server.debug('*** getExternalPort()', server.config.getExternalPort());
+            port = server.config.getExternalPort();
+        }
+        hostPath = `${server.config.ssl ? 'https' : 'http'}://localhost:${port}`;
+        // temp patch for detection issue
+        pluginPath = `/plugins/anchoralarm`;
+        anchorPlugin.enabled = true;
+        /*
+        const url = `${hostPath}/plugins`;
+        const r: Array<{ id: string }> = await fetch(url);
+        r.forEach(
+          (plugin: { id: string; version: string; data: { enabled: boolean } }) => {
+            if (plugin.id === 'anchoralarm') {
+              pluginPath = `/plugins/${plugin.id}`;
+              anchorPlugin.has = true;
+              anchorPlugin.version = plugin.version;
+              anchorPlugin.enabled = plugin.data.enabled;
+            }
+          }
+        );*/
+    }
+    catch (e) {
+        anchorPlugin.has = false;
+    }
+    server.debug('*** Anchor Alarm Plugin detected:', anchorPlugin.has);
+    server.debug('*** Anchor Alarm Plugin enabled:', anchorPlugin.enabled);
+    server.debug('*** Anchor Alarm Plugin API Path', `${hostPath}${pluginPath}`);
+    if (anchorPlugin.has) {
+        initApiEndpoints();
+    }
+};
+exports.initAnchorApi = initAnchorApi;
+const initApiEndpoints = () => {
+    server.debug(`** Registering Anchor API endpoint(s) **`);
+    server.post(`${apiBasePath}/drop`, async (req, res) => {
+        server.debug(`** POST ${apiBasePath}/drop`);
+        if (!anchorPlugin.has) {
+            res.status(400).json({
+                state: 'COMPLETED',
+                statusCode: 400,
+                message: msgPluginNotFound
+            });
+            return;
+        }
+        try {
+            const r = await (0, fetch_1.post)(`${hostPath}${pluginPath}/dropAnchor`, '{}');
+            res.status(r.statusCode).json(r);
+        }
+        catch (e) {
+            // fix plugin returned 401 error code when no position is available
+            if (e.statusCode === 401 && e.message.indexOf('no position') !== -1) {
+                e.statusCode = 400;
+            }
+            res.status(e.statusCode).json(e);
+        }
+    });
+    server.post(`${apiBasePath}/raise`, async (req, res) => {
+        server.debug(`** POST ${apiBasePath}/raise`);
+        if (!anchorPlugin.has) {
+            res.status(400).json({
+                state: 'COMPLETED',
+                statusCode: 400,
+                message: msgPluginNotFound
+            });
+            return;
+        }
+        try {
+            const r = await (0, fetch_1.post)(`${hostPath}${pluginPath}/raiseAnchor`, '{}');
+            res.status(r.statusCode).json(r);
+        }
+        catch (e) {
+            res.status(e.statusCode).json(e);
+        }
+    });
+    server.post(`${apiBasePath}/radius`, async (req, res) => {
+        server.debug(`** POST ${apiBasePath}/radius`);
+        if (!anchorPlugin.has) {
+            res.status(400).json({
+                state: 'COMPLETED',
+                statusCode: 400,
+                message: msgPluginNotFound
+            });
+            return;
+        }
+        try {
+            const val = req.body.value && typeof req.body.value === 'number'
+                ? { radius: req.body.value }
+                : {};
+            const r = await (0, fetch_1.post)(`${hostPath}${pluginPath}/setRadius`, JSON.stringify(val));
+            res.status(r.statusCode).json(r);
+        }
+        catch (e) {
+            res.status(e.statusCode).json(e);
+        }
+    });
+};

package/plugin/lib/noaa.js

@@ -0,0 +1,191 @@
+"use strict";
+// NOAA
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOAA = void 0;
+const fetch_1 = require("./fetch");
+const weather_1 = require("../weather");
+var CARDINAL_POINTS;
+(function (CARDINAL_POINTS) {
+    CARDINAL_POINTS[CARDINAL_POINTS["N"] = 0] = "N";
+    CARDINAL_POINTS[CARDINAL_POINTS["NNE"] = 22.5] = "NNE";
+    CARDINAL_POINTS[CARDINAL_POINTS["NE"] = 45] = "NE";
+    CARDINAL_POINTS[CARDINAL_POINTS["ENE"] = 67.5] = "ENE";
+    CARDINAL_POINTS[CARDINAL_POINTS["E"] = 90] = "E";
+    CARDINAL_POINTS[CARDINAL_POINTS["ESE"] = 112.5] = "ESE";
+    CARDINAL_POINTS[CARDINAL_POINTS["SE"] = 135] = "SE";
+    CARDINAL_POINTS[CARDINAL_POINTS["SSE"] = 157.5] = "SSE";
+    CARDINAL_POINTS[CARDINAL_POINTS["S"] = 180] = "S";
+    CARDINAL_POINTS[CARDINAL_POINTS["SSW"] = 202.5] = "SSW";
+    CARDINAL_POINTS[CARDINAL_POINTS["SW"] = 225] = "SW";
+    CARDINAL_POINTS[CARDINAL_POINTS["WSW"] = 247.5] = "WSW";
+    CARDINAL_POINTS[CARDINAL_POINTS["W"] = 270] = "W";
+    CARDINAL_POINTS[CARDINAL_POINTS["WNW"] = 292.5] = "WNW";
+    CARDINAL_POINTS[CARDINAL_POINTS["NW"] = 315] = "NW";
+    CARDINAL_POINTS[CARDINAL_POINTS["NNW"] = 337.5] = "NNW";
+})(CARDINAL_POINTS || (CARDINAL_POINTS = {}));
+class NOAA {
+    settings;
+    constructor(config) {
+        this.settings = config;
+    }
+    getUrl(position) {
+        const api = 'https://api.weather.gov/points';
+        if (!this.settings.apiKey || !position) {
+            return '';
+        }
+        else {
+            return `${api}/${position.latitude.toFixed(4)},${position.longitude.toFixed(4)}`;
+        }
+    }
+    fetchData = async (position) => {
+        const url = this.getUrl(position);
+        //console.log(`url`, url)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const response = await (0, fetch_1.fetch)(url);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let forecasts = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let observations = [];
+        // observations
+        if (response?.properties?.observationStations) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const stations = await (0, fetch_1.fetch)(response.properties.observationStations);
+            observations = await (0, fetch_1.fetch)(`${stations.features[0].id}/observations/latest`);
+            //console.log(`observations`, observations)
+        }
+        // forecasts
+        if (response?.properties?.forecastHourly) {
+            forecasts = await (0, fetch_1.fetch)(response.properties.forecastHourly);
+            //console.log(`forecasts`, forecasts)
+        }
+        // warnings
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const warnings = await (0, fetch_1.fetch)(`https://api.weather.gov/alerts/active?point=${position.latitude.toFixed(4)},${position.longitude.toFixed(4)}`);
+        //console.log(`warnings`, warnings)
+        return this.parseResponse({
+            position: position,
+            forecasts: forecasts?.properties?.periods ?? [],
+            observations: observations?.properties ?? null,
+            warnings: warnings?.features ?? []
+        });
+    };
+    parseResponse = (wData) => {
+        const res = {};
+        res[weather_1.defaultStationId] = {
+            name: 'Weather data relative to supplied position.',
+            position: {
+                latitude: wData.latitude,
+                longitude: wData.longitude
+            },
+            observations: this.parseNoaaObservations(wData.observations),
+            forecasts: this.parseNoaaForecasts(wData.forecasts),
+            warnings: this.parseNoaaWarnings(wData.warnings)
+        };
+        return res;
+    };
+    parseNoaaObservations(wData) {
+        const data = [];
+        let obs;
+        let v;
+        if (wData) {
+            obs = {
+                timestamp: wData.timestamp ?? null,
+                description: wData.textDescription ?? null
+            };
+            v = wData.visibility.value
+                ? wData.visibility.unitCode === 'wmoUnit:m'
+                    ? wData.visibility.value
+                    : wData.visibility.value
+                : null;
+            obs.outside.horizontalVisibility = v;
+            v = wData.temperature.value
+                ? wData.temperature.unitCode === 'wmoUnit:degC'
+                    ? wData.temperature.value + 273.15
+                    : wData.temperature.value
+                : null;
+            obs.outside.temperature = v;
+            v = wData.dewpoint.value
+                ? wData.dewpoint.unitCode === 'wmoUnit:degC'
+                    ? wData.dewpoint.value + 273.15
+                    : wData.dewpoint.value
+                : null;
+            obs.outside.dewPointTemperature = v;
+            v = wData.seaLevelPressure.value
+                ? wData.seaLevelPressure.unitCode === 'wmoUnit:Pa'
+                    ? wData.seaLevelPressure.value
+                    : wData.seaLevelPressure.value
+                : null;
+            obs.outside.pressure = v;
+            v = wData.relativeHumidity.value
+                ? wData.relativeHumidity.unitCode === 'wmoUnit:percent'
+                    ? wData.relativeHumidity.value / 100
+                    : wData.relativeHumidity.value
+                : null;
+            obs.outside.relativeHumidity = v;
+            v = wData.windSpeed.value
+                ? wData.windSpeed.unitCode === 'wmoUnit:km_h-1'
+                    ? wData.windSpeed.value / 3.6
+                    : wData.windSpeed.value
+                : null;
+            obs.wind.speedTrue = v;
+            v = wData.windDirection.value
+                ? wData.windDirection.unitCode === 'wmoUnit:degree_(angle)'
+                    ? wData.windDirection.value * (Math.PI / 180)
+                    : wData.windDirection.value
+                : null;
+            obs.wind.directionTrue = v;
+            v = wData.windGust.value
+                ? wData.windGust.unitCode === 'wmoUnit:km_h-1'
+                    ? wData.windGust.value / 3.6
+                    : wData.windGust.value
+                : null;
+            obs.wind.gust = v;
+            data.push(obs);
+        }
+        return data;
+    }
+    parseNoaaForecasts(forecasts) {
+        const data = [];
+        if (forecasts && Array.isArray(forecasts)) {
+            forecasts.forEach((f) => {
+                const forecast = {
+                    timestamp: f.startTime ?? null,
+                    description: f.shortForecast ?? null
+                };
+                forecast.outside.temperature =
+                    typeof f.temperature !== 'undefined'
+                        ? ((f.temperature - 32) * 5) / 9 + 273.15
+                        : null;
+                forecast.wind.speedTrue =
+                    parseInt(f.windSpeed.split(' ')[0]) / 2.237 ?? null;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const wd = f.windDirection
+                    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        CARDINAL_POINTS[f.windDirection]
+                    : 0;
+                forecast.wind.directionTrue = f.windDirection
+                    ? (Math.PI / 180) * wd
+                    : null;
+                data.push(forecast);
+            });
+        }
+        return data;
+    }
+    parseNoaaWarnings(alerts) {
+        const data = [];
+        if (alerts && Array.isArray(alerts)) {
+            alerts.forEach((alert) => {
+                const warn = {
+                    startTime: alert?.properties?.effective ?? null,
+                    endTime: alert?.properties?.ends ?? null,
+                    details: alert?.properties?.description ?? null,
+                    source: alert?.properties?.senderName ?? null,
+                    type: alert?.properties?.messageType ?? null
+                };
+                data.push(warn);
+            });
+        }
+        return data;
+    }
+}
+exports.NOAA = NOAA;

package/plugin/lib/openweather.js

@@ -0,0 +1,166 @@
+"use strict";
+// OpenWeather
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenWeather = void 0;
+const fetch_1 = require("./fetch");
+const weather_1 = require("../weather");
+class OpenWeather {
+    settings;
+    constructor(config) {
+        this.settings = config;
+    }
+    getUrl(position) {
+        const api = 'https://api.openweathermap.org/data/2.5/onecall';
+        if (!this.settings.apiKey || !position) {
+            return '';
+        }
+        else {
+            return `${api}?lat=${position.latitude}&lon=${position.longitude}&exclude=minutely,daily&appid=${this.settings.apiKey}`;
+        }
+    }
+    fetchData = async (position) => {
+        const url = this.getUrl(position);
+        const response = await (0, fetch_1.fetch)(url);
+        return this.parseResponse(response);
+    };
+    parseResponse = (owData) => {
+        const res = {};
+        res[weather_1.defaultStationId] = {
+            id: weather_1.defaultStationId,
+            name: 'Weather data relative to supplied position.',
+            position: {
+                latitude: owData.lat,
+                longitude: owData.lon
+            },
+            observations: this.parseOWObservations(owData),
+            forecasts: this.parseOWForecasts(owData),
+            warnings: this.parseOWWarnings(owData)
+        };
+        return res;
+    };
+    parseOWObservations(owData) {
+        //server.debug(JSON.stringify(weatherData.current))
+        const data = [];
+        let obs;
+        if (owData && owData.current) {
+            const current = owData.current;
+            obs = {
+                date: current.dt
+                    ? new Date(current.dt * 1000).toISOString()
+                    : new Date().toISOString(),
+                description: current.weather[0].description ?? '',
+                sun: {
+                    sunrise: new Date(current.sunrise * 1000).toISOString() ?? null,
+                    sunset: new Date(current.sunset * 1000).toISOString() ?? null
+                },
+                horizontalVisibility: current.visibility ?? null,
+                outside: {
+                    uvIndex: current.uvi ?? null,
+                    cloudCover: current.clouds ?? null,
+                    temperature: current.temp ?? null,
+                    feelsLikeTemperature: current.feels_like ?? null,
+                    dewPointTemperature: current.dew_point ?? null,
+                    pressure: current.pressure ? current.pressure * 100 : null,
+                    absoluteHumidity: current.humidity ?? null,
+                    precipitationType: current.rain && typeof current.rain['1h'] !== 'undefined'
+                        ? 'rain'
+                        : current.snow && typeof current.snow['1h'] !== 'undefined'
+                            ? 'snow'
+                            : null,
+                    precipitationVolume: current.rain && typeof current.rain['1h'] !== 'undefined'
+                        ? current.rain['1h']
+                        : current.snow && typeof current.snow['1h'] !== 'undefined'
+                            ? current.snow['1h']
+                            : null
+                },
+                water: {},
+                wind: {
+                    speedTrue: current.wind_speed ?? null,
+                    directionTrue: typeof current.wind_deg !== 'undefined'
+                        ? (Math.PI / 180) * current.wind_deg
+                        : null
+                }
+            };
+            data.push(obs);
+        }
+        return data;
+    }
+    parseOWForecasts(owData, period = 'hourly') {
+        //server.debug(JSON.stringify(owData[period]))
+        const data = [];
+        if (owData && owData[period] && Array.isArray(owData[period])) {
+            const forecasts = owData[period];
+            forecasts.forEach((f) => {
+                const forecast = {
+                    date: f.dt
+                        ? new Date(f.dt * 1000).toISOString()
+                        : new Date().toISOString(),
+                    description: f.weather[0].description ?? '',
+                    sun: {},
+                    outside: {},
+                    water: {},
+                    wind: {}
+                };
+                if (period === 'daily') {
+                    forecast.sun.sunrise =
+                        new Date(f.sunrise * 1000).toISOString() ?? null;
+                    forecast.sun.sunset = new Date(f.sunset * 1000).toISOString() ?? null;
+                    forecast.outside.minTemperature = f.temp.min ?? null;
+                    forecast.outside.maxTemperature = f.temp.max ?? null;
+                    forecast.outside.feelsLikeTemperature = f.feels_like.day ?? null;
+                }
+                else {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    forecast.outside.feelsLikeTemperature = f.feels_like ?? null;
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    forecast.outside.temperature = f.temp ?? null;
+                }
+                forecast.outside.dewPointTemperature = f.dew_point ?? null;
+                forecast.outside.uvIndex = f.uvi ?? null;
+                forecast.outside.cloudCover = f.clouds ?? null;
+                forecast.outside.pressure =
+                    typeof f.pressure !== 'undefined' ? f.pressure * 100 : null;
+                forecast.outside.absoluteHumidity = f.humidity ?? null;
+                forecast.wind.speedTrue = f.wind_speed ?? null;
+                forecast.wind.directionTrue =
+                    typeof f.wind_deg !== 'undefined'
+                        ? (Math.PI / 180) * f.wind_deg
+                        : null;
+                forecast.wind.gust = f.wind_gust ?? null;
+                if (f.rain && typeof f.rain['1h'] !== 'undefined') {
+                    forecast.outside.precipitationType = 'rain';
+                    forecast.outside.precipitationVolume = f.rain['1h'] ?? null;
+                }
+                else if (f.snow && typeof f.snow['1h'] !== 'undefined') {
+                    forecast.outside.precipitationType = 'snow';
+                    forecast.outside.precipitationVolume = f.snow['1h'] ?? null;
+                }
+                data.push(forecast);
+            });
+        }
+        return data;
+    }
+    parseOWWarnings(owData) {
+        //server.debug(JSON.stringify(weatherData.alerts))
+        const data = [];
+        if (owData && owData.alerts) {
+            const alerts = owData.alerts;
+            alerts.forEach((alert) => {
+                const warn = {
+                    startTime: alert.start
+                        ? new Date(alert.start * 1000).toISOString()
+                        : null,
+                    endTime: alert.end
+                        ? new Date(alert.start * 1000).toISOString()
+                        : null,
+                    details: alert.description ?? null,
+                    source: alert.sender_name ?? null,
+                    type: alert.event ?? null
+                };
+                data.push(warn);
+            });
+        }
+        return data;
+    }
+}
+exports.OpenWeather = OpenWeather;