@rhizomatics/signalk-einklabel-plugin 0.4.0 → 0.4.2

package/dist/repaintScheduler.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRepaintScheduler = startRepaintScheduler;
+const crypto_1 = require("crypto");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const config_1 = require("./config");
+const bleDiscovery_1 = require("./devices/bleDiscovery");
+const registry_1 = require("./devices/registry");
+const svgRenderer_1 = require("./render/svgRenderer");
+const binding_1 = require("./render/binding");
+const unitCategories_1 = require("./unitCategories");
+const pathMeta_1 = require("./pathMeta");
+const resolveApiUrl_1 = require("./resolveApiUrl");
+const INTERVAL_POLL_MS = 60000;
+const SUBSCRIPTION_DEBOUNCE_MS = 2000;
+function statePath(app) {
+    return (0, path_1.join)(app.getDataDirPath(), 'repaint-state.json');
+}
+function loadState(app) {
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(statePath(app), 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveState(app, state) {
+    (0, fs_1.writeFileSync)(statePath(app), JSON.stringify(state));
+}
+/** Deterministic JSON serialisation (sorted keys) so re-ordered object keys don't change the hash. */
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(',')}]`;
+    }
+    if (value !== null && typeof value === 'object') {
+        const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+        return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function hashContext(context) {
+    return (0, crypto_1.createHash)('sha1').update(stableStringify(context)).digest('hex');
+}
+/** Merges `value` into `target` at the nested location described by a dotted SignalK path. */
+function setAtPath(target, path, value) {
+    const segments = path.split('.');
+    let node = target;
+    for (const segment of segments.slice(0, -1)) {
+        const next = node[segment];
+        node[segment] = typeof next === 'object' && next !== null ? next : {};
+        node = node[segment];
+    }
+    node[segments[segments.length - 1]] = value;
+}
+/**
+ * Reads live data for exactly what a template's own bindings ask for - no separate config declaring it.
+ * `signalk`-sourced bindings are read directly (`self` via `getSelfPath`, anything else via `getPath`
+ * against that literal SignalK context) - in-process, no URL needed. `resources`-sourced bindings go
+ * through `app.resourcesApi`, in-process too. Per-path unit-conversion metadata (`pathMeta`, for
+ * automatic conversion - see `renderBinding`) and an explicit `category=` binding's resolved
+ * conversion both have no in-process equivalent (confirmed against the signalk-server source - that
+ * resolution only happens in its REST layer), so both need `apiUrl` - fetching `pathMeta` is
+ * best-effort (a missing/unreachable server just means no automatic conversion), but a `category=`
+ * binding is a declared dependency, so a missing `apiUrl` is a hard error there.
+ */
+async function assembleRawContext(app, apiUrl, bindings) {
+    var _a;
+    const signalk = {};
+    const seenSignalk = new Set();
+    for (const binding of bindings) {
+        if (binding.source !== 'signalk')
+            continue;
+        const key = `${binding.context} ${binding.path}`;
+        if (seenSignalk.has(key))
+            continue;
+        seenSignalk.add(key);
+        const value = binding.context === 'self' ? app.getSelfPath(binding.path) : app.getPath(`${binding.context}.${binding.path}`);
+        const namespace = (signalk[_a = binding.context] ?? (signalk[_a] = {}));
+        setAtPath(namespace, binding.path, value);
+    }
+    signalk.self ?? (signalk.self = {});
+    const pathMeta = {};
+    const signalkContexts = new Set(bindings.filter((binding) => binding.source === 'signalk').map((binding) => binding.context));
+    if (apiUrl) {
+        for (const ctx of signalkContexts) {
+            try {
+                pathMeta[ctx] = await (0, pathMeta_1.fetchPathMeta)(apiUrl, ctx);
+            }
+            catch (err) {
+                app.debug(`could not fetch path metadata for context "${ctx}" (${err.message}) - automatic unit conversion will show raw values`);
+            }
+        }
+    }
+    const resources = {};
+    const resourceNames = new Set(bindings.filter((binding) => binding.source === 'resources').map((binding) => binding.resource));
+    for (const name of resourceNames) {
+        // `listResources`'s type only allows the standard SignalKResourceType union, but the underlying
+        // Resources API (and a custom provider like signalk-tides, registered under the non-standard
+        // "tides" type) accepts any registered resource type string - this cast matches `getResource`'s
+        // wider, accurate signature.
+        resources[name] = await app.resourcesApi.listResources(name, {});
+    }
+    const categoryNames = new Set(bindings.filter((binding) => binding.category).map((binding) => binding.category));
+    if (categoryNames.size > 0 && !apiUrl) {
+        throw new Error(`binding references categor${categoryNames.size > 1 ? 'ies' : 'y'} "${[...categoryNames].join(', ')}" but no SignalK API base URL is configured`);
+    }
+    const categories = apiUrl ? await (0, unitCategories_1.fetchCategoryDisplayUnits)(apiUrl, categoryNames) : {};
+    return { signalk, resources, pathMeta, categories };
+}
+function clearForceRepaint(app, friendlyName) {
+    const current = { ...app.readPluginOptions() };
+    const devices = (current.devices ?? []).map((device) => device.friendlyName === friendlyName ? { ...device, forceRepaint: false } : device);
+    app.savePluginOptions({ ...current, devices }, (err) => {
+        if (err)
+            app.debug(`failed to clear forceRepaint for "${friendlyName}": ${err.message}`);
+    });
+}
+async function considerRepaint(app, config, device, state, getApiUrl) {
+    const model = (0, config_1.parseDevice)(device.device);
+    const driver = model && (0, registry_1.getDriver)(model.vendor);
+    const metadata = model && driver?.metadataForPid(model.pid, model.hwVersion);
+    if (!model || !driver || !metadata) {
+        app.debug(`"${device.friendlyName}": no driver/metadata for device "${device.device}", skipping`);
+        return;
+    }
+    const templatePath = (0, config_1.resolveTemplatePath)((0, config_1.resolveTemplatesDir)(config.templatesDir), device.templateName);
+    const bindings = (0, binding_1.findBindings)((0, fs_1.readFileSync)(templatePath, 'utf-8'));
+    const apiUrl = await getApiUrl().catch((err) => {
+        app.debug(`"${device.friendlyName}": ${err.message}`);
+        return undefined;
+    });
+    const rawContext = await assembleRawContext(app, apiUrl, bindings);
+    const hash = hashContext(rawContext);
+    if (state[device.friendlyName]?.hash === hash && !device.forceRepaint) {
+        app.debug(`"${device.friendlyName}": data unchanged, skipping repaint`);
+        return;
+    }
+    const renderContext = { ...rawContext, meta: { repainted: new Date().toISOString() } };
+    const renderer = new svgRenderer_1.SvgRenderer();
+    const bitmap = await renderer.render(templatePath, renderContext, metadata.width, metadata.height - metadata.voffset);
+    const connectTimeoutMs = config.paintConnectTimeoutSeconds * 1000;
+    await (0, bleDiscovery_1.withRetries)(config.paintRetries, async (attempt) => {
+        if (attempt > 1) {
+            app.debug(`"${device.friendlyName}": paint attempt ${attempt}/${config.paintRetries}`);
+        }
+        await driver.paint(bitmap, { address: model.address, aesKey: device.aesKey, connectTimeoutMs });
+    });
+    state[device.friendlyName] = { hash };
+    saveState(app, state);
+    if (device.forceRepaint) {
+        clearForceRepaint(app, device.friendlyName);
+    }
+    app.debug(`"${device.friendlyName}": repainted`);
+}
+function startRepaintScheduler(app, config) {
+    const state = loadState(app);
+    const unsubscribes = [];
+    const getApiUrl = (0, resolveApiUrl_1.createApiUrlResolver)(config.signalkApiUrl);
+    const repaint = (device) => considerRepaint(app, config, device, state, getApiUrl).catch((err) => app.debug(`"${device.friendlyName}": repaint failed: ${err.message}`));
+    const intervalDevices = config.devices.filter((device) => device.repaintTrigger === 'interval');
+    if (intervalDevices.length > 0) {
+        const timer = setInterval(() => {
+            const now = new Date();
+            for (const device of intervalDevices) {
+                const hours = device.intervalHours ?? 1;
+                const minute = device.intervalMinute ?? 0;
+                if (now.getHours() % hours === 0 && now.getMinutes() === minute) {
+                    repaint(device);
+                }
+            }
+        }, INTERVAL_POLL_MS);
+        unsubscribes.push(() => clearInterval(timer));
+    }
+    for (const device of config.devices) {
+        if (device.repaintTrigger === 'subscription' && device.triggerPath) {
+            const stream = app.streambundle.getSelfStream(device.triggerPath).debounce(SUBSCRIPTION_DEBOUNCE_MS);
+            const unsub = stream.onValue(() => repaint(device));
+            unsubscribes.push(unsub);
+        }
+    }
+    // Check every device once at startup - harmless given hash dedup, and covers newly-added
+    // devices or a forceRepaint left set from before a restart.
+    for (const device of config.devices) {
+        repaint(device);
+    }
+    return {
+        stop() {
+            for (const unsubscribe of unsubscribes)
+                unsubscribe();
+        },
+    };
+}

package/dist/resolveApiUrl.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This whole module is a workaround for a gap in the plugin API, not a permanent design choice -
+ * `resourcesApi`/`weatherApi`/`courseApi` etc. on `ServerAPI` exist because of an ongoing upstream
+ * effort to broaden what plugins can reach in-process; unit-preferences resolution (and enhanced
+ * per-path metadata) just hasn't been added yet. If/when it is, this probing - and `unitCategories.ts`'s
+ * client-side recomposition of the same resolution - can likely be replaced with a direct in-process
+ * call, dropping the need for `signalkApiUrl` entirely.
+ */
+/**
+ * The only realistic values for this server's own base URL, in likelihood order - the plugin always
+ * runs on the same host as the server, so it's always the loopback address, and the port is determined
+ * entirely by install method: a bare `npm install` defaults to 3000; container/systemd installs
+ * commonly default to 80, or 443 if TLS-terminated locally.
+ */
+export declare const SIGNALK_API_URL_OPTIONS: string[];
+/**
+ * Resolves this server's own base URL. If `configuredUrl` is set, trusts it but still confirms it
+ * actually works, so a bad config value surfaces a clear error instead of failing silently on every
+ * `category=` binding or per-path metadata fetch. If unset, probes `SIGNALK_API_URL_OPTIONS` in order
+ * and uses the first that responds.
+ */
+export declare function resolveSignalkApiUrl(configuredUrl: string | undefined): Promise<string>;
+/**
+ * Memoizes a successful resolution only - a failure (server not ready yet, anonymous access
+ * temporarily misconfigured, ...) is retried on the next call rather than cached forever, since the
+ * port itself won't change once the server's actually up.
+ */
+export declare function createApiUrlResolver(configuredUrl: string | undefined): () => Promise<string>;

package/dist/resolveApiUrl.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIGNALK_API_URL_OPTIONS = void 0;
+exports.resolveSignalkApiUrl = resolveSignalkApiUrl;
+exports.createApiUrlResolver = createApiUrlResolver;
+const httpJson_1 = require("./httpJson");
+/**
+ * This whole module is a workaround for a gap in the plugin API, not a permanent design choice -
+ * `resourcesApi`/`weatherApi`/`courseApi` etc. on `ServerAPI` exist because of an ongoing upstream
+ * effort to broaden what plugins can reach in-process; unit-preferences resolution (and enhanced
+ * per-path metadata) just hasn't been added yet. If/when it is, this probing - and `unitCategories.ts`'s
+ * client-side recomposition of the same resolution - can likely be replaced with a direct in-process
+ * call, dropping the need for `signalkApiUrl` entirely.
+ */
+/**
+ * The only realistic values for this server's own base URL, in likelihood order - the plugin always
+ * runs on the same host as the server, so it's always the loopback address, and the port is determined
+ * entirely by install method: a bare `npm install` defaults to 3000; container/systemd installs
+ * commonly default to 80, or 443 if TLS-terminated locally.
+ */
+exports.SIGNALK_API_URL_OPTIONS = ['http://localhost:3000', 'http://localhost', 'https://localhost'];
+/** Cheap, always-required (for `category=` resolution) and read-only, so safe to use as a connectivity+access probe. */
+const PROBE_PATH = '/signalk/v1/unitpreferences/categories';
+async function probe(url) {
+    try {
+        await (0, httpJson_1.fetchJson)(`${url}${PROBE_PATH}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolves this server's own base URL. If `configuredUrl` is set, trusts it but still confirms it
+ * actually works, so a bad config value surfaces a clear error instead of failing silently on every
+ * `category=` binding or per-path metadata fetch. If unset, probes `SIGNALK_API_URL_OPTIONS` in order
+ * and uses the first that responds.
+ */
+async function resolveSignalkApiUrl(configuredUrl) {
+    const candidates = configuredUrl ? [configuredUrl] : exports.SIGNALK_API_URL_OPTIONS;
+    for (const url of candidates) {
+        if (await probe(url))
+            return url;
+    }
+    throw new Error(configuredUrl
+        ? `configured SignalK API base URL "${configuredUrl}" did not respond to ${PROBE_PATH} - check the port, and that anonymous read access is enabled`
+        : `could not reach this server's API on any of ${exports.SIGNALK_API_URL_OPTIONS.join(', ')} - it may be on a different port, or anonymous read access may not be enabled`);
+}
+/**
+ * Memoizes a successful resolution only - a failure (server not ready yet, anonymous access
+ * temporarily misconfigured, ...) is retried on the next call rather than cached forever, since the
+ * port itself won't change once the server's actually up.
+ */
+function createApiUrlResolver(configuredUrl) {
+    let resolved;
+    return async () => {
+        if (!resolved) {
+            resolved = await resolveSignalkApiUrl(configuredUrl);
+        }
+        return resolved;
+    };
+}

package/dist/unitCategories.d.ts

@@ -0,0 +1,11 @@
+import { DisplayUnits } from './render/formatters';
+/**
+ * Resolves `category=` bindings (e.g. `category=depth` on a `source=resources` value with no per-path
+ * metadata of its own to auto-convert from) against this server's unit-preferences setup.
+ *
+ * Mirrors signalk-server's own `resolveDisplayUnits` (`src/unitpreferences/resolver.ts`), composed
+ * client-side from the three REST endpoints that expose the same underlying data - that resolver isn't
+ * exposed via `ServerAPI`, it's an internal signalk-server module, so both the live plugin
+ * (repaintScheduler.ts) and the CLI (cli/liveContext.ts) fetch it the same way, over HTTP.
+ */
+export declare function fetchCategoryDisplayUnits(apiUrl: string, categoryNames: Set<string>): Promise<Record<string, DisplayUnits>>;

package/dist/unitCategories.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCategoryDisplayUnits = fetchCategoryDisplayUnits;
+const httpJson_1 = require("./httpJson");
+const CATEGORIES_PATH = '/signalk/v1/unitpreferences/categories';
+const ACTIVE_PRESET_PATH = '/signalk/v1/unitpreferences/active';
+const DEFINITIONS_PATH = '/signalk/v1/unitpreferences/definitions';
+/**
+ * Resolves `category=` bindings (e.g. `category=depth` on a `source=resources` value with no per-path
+ * metadata of its own to auto-convert from) against this server's unit-preferences setup.
+ *
+ * Mirrors signalk-server's own `resolveDisplayUnits` (`src/unitpreferences/resolver.ts`), composed
+ * client-side from the three REST endpoints that expose the same underlying data - that resolver isn't
+ * exposed via `ServerAPI`, it's an internal signalk-server module, so both the live plugin
+ * (repaintScheduler.ts) and the CLI (cli/liveContext.ts) fetch it the same way, over HTTP.
+ */
+async function fetchCategoryDisplayUnits(apiUrl, categoryNames) {
+    if (categoryNames.size === 0)
+        return {};
+    const [categoryMap, activePreset, definitions] = await Promise.all([
+        (0, httpJson_1.fetchJson)(`${apiUrl}${CATEGORIES_PATH}`),
+        (0, httpJson_1.fetchJson)(`${apiUrl}${ACTIVE_PRESET_PATH}`),
+        (0, httpJson_1.fetchJson)(`${apiUrl}${DEFINITIONS_PATH}`),
+    ]);
+    const result = {};
+    for (const category of categoryNames) {
+        const siUnit = categoryMap.categoryToBaseUnit?.[category];
+        if (!siUnit) {
+            throw new Error(`unknown unit category "${category}" - not in this server's categoryToBaseUnit map`);
+        }
+        const presetCategory = activePreset.categories?.[category];
+        const targetUnit = presetCategory?.targetUnit ?? siUnit;
+        // A conversion entry only exists for a non-identity target unit - e.g. siUnit "m"/targetUnit "m"
+        // (the common case for depth on the default metric preset) has no "m"->"m" entry in definitions.
+        // Fall back to the target unit's own name as the symbol in that case, rather than showing nothing.
+        const conversion = targetUnit !== siUnit ? definitions[siUnit]?.conversions?.[targetUnit] : undefined;
+        result[category] = {
+            category,
+            targetUnit,
+            formula: conversion?.formula,
+            symbol: conversion?.symbol ?? targetUnit,
+            displayFormat: presetCategory?.displayFormat,
+        };
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhizomatics/signalk-einklabel-plugin",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "SignalK plugin that renders selected SignalK data to eInk Electronic Shelf Labels",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,6 +10,7 @@
   "files": [
     "dist",
     "templates",
+    "docs",
     "CHANGELOG.md",
     "README.md"
   ],
@@ -17,11 +18,12 @@
     "build": "tsc",
     "watch": "tsc --watch",
     "cli": "ts-node src/cli/index.ts",
-    "test": "node --require ts-node/register --test \"src/**/*.test.ts\""
+    "test": "node --require ts-node/register --test \"src/**/*.test.ts\"",
+    "prepublishOnly": "npm run build"
   },
   "signalk":{
-    "displayName":"eInk ESL Instruments",
-    "appIcon": "/docs/assets/icons/icon_tmp.png",
+    "displayName":"eInk Label Instruments",
+    "appIcon": "docs/assets/icons/icon_tmp.png",
     "screenshots": [
       "docs/assets/screenshots/example_tidal_clock.png"
     ]

package/templates/tide.svg

@@ -63,15 +63,15 @@
      font-size="18"
      font-family="serif"
      fill="black"
-     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#999999;stroke-width:2.39571"
+     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#ffffff;stroke-width:2.39571"
      transform="scale(0.83037506,1.2042751)"><tspan
        sodipodi:role="line"
        id="tspan1"
        x="325.49939"
        y="195.87753"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:2.39571;fill:#999999">signalk-einklabel-plugin</tspan></text>
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:11.99999995px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:2.39571;fill:#ffffff">signalk-einklabel-plugin</tspan></text>
   <text
-     id="station.name-8-2"
+     id="last_repaint"
      x="4.3477793"
      y="201.9895"
      font-size="18"
@@ -81,10 +81,7 @@
      transform="scale(0.85412558,1.170788)"><desc
        id="desc12">source=einklabel,path=repainted,format=local_datetime_short</desc><tspan
        sodipodi:role="line"
-       id="tspan3"
-       x="4.3477793"
-       y="201.9895"
-       style="stroke-width:1.19309;-inkscape-font-specification:'Sans, Normal';font-family:Sans;font-weight:normal;font-style:normal;font-stretch:normal;font-variant:normal;font-size:13.33333347px;font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal">Last updated 27 Jun 26 18:05</tspan></text>
+       id="tspan3">27 Jun 26 18:05</tspan></text>
   <text
      id="extremes.0"
      x="7.9661016"
@@ -92,7 +89,8 @@
      font-size="14"
      font-family="monospace"
      fill="black"
-     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:18.6667px;font-family:monospace;-inkscape-font-specification:'monospace, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#ff0000">High Water</text>
+     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:18.6667px;font-family:monospace;-inkscape-font-specification:'monospace, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#ff0000"><desc
+   id="desc13">source=resources,resource=tides,path=extremes.[0].label</desc>High Water</text>
   <text
      id="extremes.1"
      x="13.35283"
@@ -100,7 +98,8 @@
      font-size="14"
      font-family="monospace"
      fill="black"
-     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:18.6667px;font-family:monospace;-inkscape-font-specification:'monospace, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#ff0000">Low Water</text>
+     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:18.6667px;font-family:monospace;-inkscape-font-specification:'monospace, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#ff0000"><desc
+   id="desc14">source=resources,resource=tides,path=extremes.[1].label</desc>Low Water</text>
   <text
      id="extremes.2"
      x="7.9661016"
@@ -108,7 +107,8 @@
      font-size="14"
      font-family="monospace"
      fill="red"
-     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:18.6667px;font-family:monospace;-inkscape-font-specification:'monospace, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#ff0000">High Water</text>
+     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:18.6667px;font-family:monospace;-inkscape-font-specification:'monospace, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#ff0000"><desc
+   id="desc15">source=resources,resource=tides,path=extremes.[2].label</desc>High Water</text>
   <text
      id="environment.time.timezoneRegion"
      x="338.47461"