signalk-tides 2.1.0 → 2.1.2

package/dist/sources/stormglass.js

@@ -1,199 +0,0 @@
-import path from "path";
-import { getDistance } from "geolib";
-import makeFetchHappen from "make-fetch-happen";
-const BASE_URL = "https://api.stormglass.io/v2/tide";
-// StormGlass tide predictions accept only these two datums — its API rejects
-// anything else (e.g. "LAT not valid. Should be one of: MLLW, MSL"). It exposes
-// no datum offset table, so the values are placeholders; the @neaps UI only
-// uses the keys to populate the datum selector. MSL is StormGlass's default.
-const STORMGLASS_DEFAULT_DATUM = "MSL";
-const STORMGLASS_DATUMS = { MSL: 0, MLLW: 0 };
-function toStation(s) {
-    return {
-        id: `stormglass/${s.name}`,
-        name: s.name,
-        latitude: s.lat,
-        longitude: s.lng,
-        source: { id: "stormglass", name: s.source },
-        datums: { ...STORMGLASS_DATUMS },
-        defaultDatum: STORMGLASS_DEFAULT_DATUM,
-        ...("distance" in s ? { distance: s.distance * 1000 } : {}), // km → meters
-    };
-}
-function toStationSummary(s) {
-    return {
-        id: `stormglass/${s.name}`,
-        name: s.name,
-        latitude: s.lat,
-        longitude: s.lng,
-    };
-}
-function toExtreme(e) {
-    const high = e.type === "high";
-    return {
-        time: new Date(e.time),
-        level: e.height,
-        high,
-        low: !high,
-        label: high ? "High" : "Low",
-    };
-}
-export default function (app) {
-    return {
-        id: "stormglass",
-        title: "StormGlass.io",
-        properties: {
-            stormglassApiKey: {
-                type: "string",
-                title: "StormGlass.io API key",
-            },
-        },
-        start(props = {}) {
-            const { stormglassApiKey } = props;
-            app.debug("Using StormGlass.io API");
-            const fetch = props._fetch ?? makeFetchHappen.defaults({
-                cachePath: path.join(app.getDataDirPath(), "stormglass", "http-cache"),
-                headers: { Authorization: stormglassApiKey ?? "" },
-            });
-            let cachedStations = null;
-            async function loadStations() {
-                if (cachedStations)
-                    return cachedStations;
-                app.debug("StormGlass: Loading stations list");
-                const res = await fetch(`${BASE_URL}/stations`);
-                if (!res.ok)
-                    throw new Error("Failed to fetch StormGlass stations: " + res.statusText);
-                const data = (await res.json());
-                cachedStations = data.data;
-                return cachedStations;
-            }
-            function predictionParams(options) {
-                const params = {
-                    start: options.start.toISOString(),
-                    end: options.end.toISOString(),
-                };
-                if (options.datum)
-                    params.datum = options.datum;
-                return params;
-            }
-            async function findStationByName(id) {
-                const stations = await loadStations();
-                const rawName = id.replace(/^stormglass\//, "");
-                const found = stations.find((s) => s.name === rawName);
-                if (!found)
-                    throw new Error(`Station not found: ${id}`);
-                return found;
-            }
-            const provider = {
-                async getExtremesPrediction(options) {
-                    const endpoint = new URL(`${BASE_URL}/extremes/point`);
-                    endpoint.search = new URLSearchParams({
-                        lat: String(options.latitude),
-                        lng: String(options.longitude),
-                        ...predictionParams(options),
-                    }).toString();
-                    app.debug("Fetching StormGlass extremes: " + endpoint);
-                    const res = await fetch(endpoint.toString());
-                    if (!res.ok)
-                        throw new Error("Failed to fetch StormGlass extremes: " + res.statusText);
-                    const data = (await res.json());
-                    const station = toStation(data.meta.station);
-                    return {
-                        datum: data.meta.datum ?? options.datum,
-                        units: options.units ?? "meters",
-                        station,
-                        distance: data.meta.station.distance * 1000,
-                        extremes: data.data.map(toExtreme),
-                    };
-                },
-                async getTimelinePrediction(options) {
-                    const endpoint = new URL(`${BASE_URL}/sea-level/point`);
-                    endpoint.search = new URLSearchParams({
-                        lat: String(options.latitude),
-                        lng: String(options.longitude),
-                        ...predictionParams(options),
-                    }).toString();
-                    app.debug("Fetching StormGlass sea level: " + endpoint);
-                    const res = await fetch(endpoint.toString());
-                    if (!res.ok)
-                        throw new Error("Failed to fetch StormGlass sea level: " + res.statusText);
-                    const data = (await res.json());
-                    const station = toStation(data.meta.station);
-                    return {
-                        datum: data.meta.datum ?? options.datum,
-                        units: options.units ?? "meters",
-                        station,
-                        distance: data.meta.station.distance * 1000,
-                        timeline: data.data.map((e) => ({
-                            time: new Date(e.time),
-                            level: e.sg,
-                        })),
-                    };
-                },
-                async findStation(id) {
-                    return toStation(await findStationByName(id));
-                },
-                async searchStations(query, options) {
-                    const stations = await loadStations();
-                    const q = query.toLowerCase();
-                    const limit = options?.maxResults ?? 10;
-                    return stations
-                        .filter((s) => s.name.toLowerCase().includes(q))
-                        .slice(0, limit)
-                        .map(toStationSummary);
-                },
-                async stationsNear(options) {
-                    const stations = await loadStations();
-                    const withDist = stations.map((s) => ({
-                        ...s,
-                        distance: getDistance(options, {
-                            latitude: s.lat,
-                            longitude: s.lng,
-                        }),
-                    }));
-                    let sorted = withDist.sort((a, b) => a.distance - b.distance);
-                    if (options.maxDistance) {
-                        sorted = sorted.filter((s) => s.distance <= options.maxDistance);
-                    }
-                    return sorted.slice(0, options.maxResults ?? 10).map((s) => ({
-                        ...toStation(s),
-                        distance: s.distance,
-                    }));
-                },
-                async stationsWithin(bbox) {
-                    const [minLon, minLat, maxLon, maxLat] = bbox;
-                    // StormGlass format: topRight:bottomLeft → maxLat,maxLon:minLat,minLon
-                    const box = `${maxLat},${maxLon}:${minLat},${minLon}`;
-                    const endpoint = new URL(`${BASE_URL}/stations/area`);
-                    endpoint.search = new URLSearchParams({ box }).toString();
-                    app.debug("Fetching StormGlass stations area: " + endpoint);
-                    const res = await fetch(endpoint.toString());
-                    if (!res.ok)
-                        throw new Error("Failed to fetch StormGlass stations: " + res.statusText);
-                    const data = (await res.json());
-                    return data.data.map(toStationSummary);
-                },
-                async stations() {
-                    return (await loadStations()).map(toStationSummary);
-                },
-                async getStationExtremes(id, options) {
-                    const station = await findStationByName(id);
-                    return provider.getExtremesPrediction({
-                        latitude: station.lat,
-                        longitude: station.lng,
-                        ...options,
-                    });
-                },
-                async getStationTimeline(id, options) {
-                    const station = await findStationByName(id);
-                    return provider.getTimelinePrediction({
-                        latitude: station.lat,
-                        longitude: station.lng,
-                        ...options,
-                    });
-                },
-            };
-            return provider;
-        },
-    };
-}

package/dist/sources/worldtides.js

@@ -1,225 +0,0 @@
-import path from "path";
-import makeFetchHappen from "make-fetch-happen";
-import FileCache from "../cache.js";
-const BASE_URL = "https://www.worldtides.info/api/v3";
-function formatDate(date) {
-    return date.toISOString().slice(0, 10);
-}
-function daysBetween(start, end) {
-    return Math.min(7, Math.max(1, Math.ceil((end.getTime() - start.getTime()) / (24 * 60 * 60 * 1000))));
-}
-/**
- * WorldTides is purely position-based — it has no get-station-by-id API — so we
- * encode the station's coordinates into its ID. That lets the station-detail
- * endpoints (findStation/getStation*) resolve back to a position to query,
- * which is what the vessel/current redirect flow needs.
- */
-function stationId(latitude, longitude) {
-    return `worldtides/${latitude},${longitude}`;
-}
-function parseStationId(id) {
-    const parts = id.replace(/^worldtides\//, "").split(",");
-    const [latitude, longitude] = parts.map(Number);
-    if (parts.length !== 2 || Number.isNaN(latitude) || Number.isNaN(longitude)) {
-        throw new Error(`Invalid WorldTides station ID: ${id}`);
-    }
-    return { latitude, longitude };
-}
-function toDatums(datums = []) {
-    return Object.fromEntries(datums.map((d) => [d.name, d.height]));
-}
-function toExtreme(e) {
-    const high = e.type === "High";
-    return {
-        time: new Date(e.dt * 1000),
-        level: e.height,
-        high,
-        low: !high,
-        label: high ? "High" : "Low",
-    };
-}
-const source = {
-    id: "worldtides",
-    name: "WorldTides.info",
-    url: "https://www.worldtides.info",
-};
-export default function (app) {
-    return {
-        id: "worldtides",
-        title: "WorldTides.info",
-        properties: {
-            worldtidesApiKey: {
-                type: "string",
-                title: "WorldTides.info API key",
-            },
-        },
-        start(props = {}) {
-            const { worldtidesApiKey = "" } = props;
-            app.debug("Using WorldTides API");
-            const fetch = props._fetch ?? makeFetchHappen.defaults({
-                cachePath: path.join(app.getDataDirPath(), "worldtides", "http-cache"),
-            });
-            // Datums are location-specific values but a fixed catalog of names; cache
-            // them per station so we only spend an API credit on them once.
-            const datumsCache = new FileCache(path.join(app.getDataDirPath(), "worldtides", "datums"));
-            const datumsInFlight = new Map();
-            async function apiRequest(params) {
-                const endpoint = new URL(BASE_URL);
-                endpoint.search = new URLSearchParams({
-                    key: worldtidesApiKey,
-                    ...params,
-                }).toString();
-                app.debug("Fetching WorldTides: " + endpoint);
-                const res = await fetch(endpoint.toString());
-                if (!res.ok)
-                    throw new Error("Failed to fetch WorldTides: " + res.statusText);
-                const data = (await res.json());
-                if (data.status !== 200)
-                    throw new Error(data.error ?? "WorldTides API error");
-                return data;
-            }
-            function fetchDatums(latitude, longitude) {
-                const key = `${latitude.toFixed(4)},${longitude.toFixed(4)}`;
-                let pending = datumsInFlight.get(key);
-                if (!pending) {
-                    pending = loadDatums(latitude, longitude, key);
-                    datumsInFlight.set(key, pending);
-                }
-                return pending;
-            }
-            async function loadDatums(latitude, longitude, key) {
-                const cached = (await datumsCache.get(key));
-                if (cached)
-                    return cached;
-                try {
-                    const data = await apiRequest({
-                        datums: "",
-                        lat: String(latitude),
-                        lon: String(longitude),
-                    });
-                    const datums = toDatums(data.datums);
-                    await datumsCache.set(key, datums);
-                    return datums;
-                }
-                catch (e) {
-                    // Don't cache failures, so they're retried next time.
-                    app.debug(`WorldTides: failed to fetch datums for ${key}: ${e}`);
-                    return {};
-                }
-            }
-            /**
-             * Build a full Station from an API response. If the response already
-             * carries datums (the datums endpoint returns them inline) they're used
-             * directly; otherwise they're fetched (and cached) for the station.
-             */
-            async function buildStation(data) {
-                const datums = data.datums
-                    ? toDatums(data.datums)
-                    : await fetchDatums(data.responseLat, data.responseLon);
-                return {
-                    id: stationId(data.responseLat, data.responseLon),
-                    name: `${data.station} (${data.atlas})`,
-                    latitude: data.responseLat,
-                    longitude: data.responseLon,
-                    timezone: data.timezone,
-                    source,
-                    datums,
-                    defaultDatum: data.responseDatum,
-                };
-            }
-            function toStationSummary(s) {
-                return {
-                    id: stationId(s.lat, s.lon),
-                    name: s.name,
-                    latitude: s.lat,
-                    longitude: s.lon,
-                    timezone: s.timezone,
-                };
-            }
-            function positionParams(options) {
-                return {
-                    lat: String(options.latitude),
-                    lon: String(options.longitude),
-                };
-            }
-            function predictionParams(options) {
-                const params = {
-                    date: formatDate(options.start),
-                    days: String(daysBetween(options.start, options.end)),
-                };
-                if (options.datum)
-                    params.datum = options.datum;
-                return params;
-            }
-            const provider = {
-                async getExtremesPrediction(options) {
-                    const data = await apiRequest({
-                        extremes: "",
-                        ...positionParams(options),
-                        ...predictionParams(options),
-                    });
-                    return {
-                        datum: data.responseDatum ?? options.datum,
-                        units: options.units ?? "meters",
-                        station: await buildStation(data),
-                        extremes: (data.extremes ?? []).map(toExtreme),
-                    };
-                },
-                async getTimelinePrediction(options) {
-                    const data = await apiRequest({
-                        heights: "",
-                        step: "600", // 10-minute intervals
-                        ...positionParams(options),
-                        ...predictionParams(options),
-                    });
-                    return {
-                        datum: data.responseDatum ?? options.datum,
-                        units: options.units ?? "meters",
-                        station: await buildStation(data),
-                        timeline: (data.heights ?? []).map((h) => ({
-                            time: new Date(h.dt * 1000),
-                            level: h.height,
-                        })),
-                    };
-                },
-                async stationsNear(options) {
-                    const distKm = options.maxDistance
-                        ? Math.ceil(options.maxDistance / 1000)
-                        : 50;
-                    const data = await apiRequest({
-                        stations: "",
-                        ...positionParams(options),
-                        stationDistance: String(distKm),
-                    });
-                    return (data.stations ?? [])
-                        .slice(0, options.maxResults ?? 10)
-                        .map((s) => ({ ...toStationSummary(s), source }));
-                },
-                async findStation(id) {
-                    // Resolve the station's coordinates back to a position and fetch its
-                    // datums (which the response returns inline).
-                    const { latitude, longitude } = parseStationId(id);
-                    const data = await apiRequest({
-                        datums: "",
-                        lat: String(latitude),
-                        lon: String(longitude),
-                    });
-                    return buildStation(data);
-                },
-                getStationExtremes(id, options) {
-                    return provider.getExtremesPrediction({
-                        ...parseStationId(id),
-                        ...options,
-                    });
-                },
-                getStationTimeline(id, options) {
-                    return provider.getTimelinePrediction({
-                        ...parseStationId(id),
-                        ...options,
-                    });
-                },
-            };
-            return provider;
-        },
-    };
-}

package/dist/types.js

@@ -1 +0,0 @@
-export {};