feat(webconfig): fold antenna location into the MLAT section

Latitude/longitude/altitude now live inside the MLAT control — revealed on enable, saved together in one apply. Adds verify-on-map and elevation links, and accepts feet for altitude (stored as canonical metres, shown in the viewer's unit).

Author: d4rken

internal/clientvalidators/display_test.go

@@ -0,0 +1,162 @@
+package clientvalidators
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// displayRunnerRel is the node harness that exercises the client-only
+// altitude display + locale helpers in app.js (see run_js_display.js).
+const displayRunnerRel = "testdata/run_js_display.js"
+
+type localeCase struct {
+	Languages []string
+	Imperial  bool
+}
+
+type altDisplayCase struct {
+	Metres   string
+	Imperial bool
+	Output   string
+}
+
+// runJSDisplay invokes the display harness with the given cases and returns
+// the JS results keyed for lookup. Mirrors runJSValidators' node-subprocess
+// shape; kept separate so the validator-parity flow stays untouched.
+func runJSDisplay(t *testing.T, locales []localeCase, alts []altDisplayCase) (map[string]bool, map[string]string) {
+	t.Helper()
+
+	type reqLocale struct {
+		Languages []string `json:"languages"`
+	}
+	type reqAlt struct {
+		Metres   string `json:"metres"`
+		Imperial bool   `json:"imperial"`
+	}
+	req := struct {
+		LocaleCases     []reqLocale `json:"localeCases"`
+		AltDisplayCases []reqAlt    `json:"altDisplayCases"`
+	}{}
+	for _, c := range locales {
+		req.LocaleCases = append(req.LocaleCases, reqLocale{Languages: c.Languages})
+	}
+	for _, c := range alts {
+		req.AltDisplayCases = append(req.AltDisplayCases, reqAlt{Metres: c.Metres, Imperial: c.Imperial})
+	}
+	body, err := json.Marshal(req)
+	if err != nil {
+		t.Fatalf("marshal display request: %v", err)
+	}
+
+	appJSPath, err := filepath.Abs(appJSRel)
+	if err != nil {
+		t.Fatalf("abs app.js: %v", err)
+	}
+	runnerPath, err := filepath.Abs(displayRunnerRel)
+	if err != nil {
+		t.Fatalf("abs runner: %v", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "node", runnerPath, appJSPath)
+	cmd.Stdin = strings.NewReader(string(body))
+	var stdout, stderr strings.Builder
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("node display runner failed: %v; stderr: %s", err, stderr.String())
+	}
+
+	var resp struct {
+		LocaleResults []struct {
+			Languages []string `json:"languages"`
+			Imperial  bool     `json:"imperial"`
+		} `json:"localeResults"`
+		AltDisplayResults []struct {
+			Metres   string `json:"metres"`
+			Imperial bool   `json:"imperial"`
+			Output   string `json:"output"`
+		} `json:"altDisplayResults"`
+		Errors []string `json:"errors"`
+	}
+	if err := json.Unmarshal([]byte(stdout.String()), &resp); err != nil {
+		t.Fatalf("decode node output: %v; raw: %q", err, stdout.String())
+	}
+	if len(resp.Errors) > 0 {
+		t.Fatalf("display runner reported errors: %v", resp.Errors)
+	}
+
+	localeOut := make(map[string]bool, len(resp.LocaleResults))
+	for _, r := range resp.LocaleResults {
+		localeOut[strings.Join(r.Languages, ",")] = r.Imperial
+	}
+	altOut := make(map[string]string, len(resp.AltDisplayResults))
+	for _, r := range resp.AltDisplayResults {
+		altOut[altKey(r.Metres, r.Imperial)] = r.Output
+	}
+	return localeOut, altOut
+}
+
+func altKey(metres string, imperial bool) string {
+	return fmt.Sprintf("%s|%t", metres, imperial)
+}
+
+// TestImperialLengthFromLanguages pins the *-us region rule the altitude
+// field uses to pick its display unit, mirroring the server-side
+// tempUnitFromAcceptLanguage contract.
+func TestImperialLengthFromLanguages(t *testing.T) {
+	cases := []localeCase{
+		{Languages: []string{"en-US", "en"}, Imperial: true},
+		{Languages: []string{"es-US"}, Imperial: true},
+		{Languages: []string{"en-GB", "en"}, Imperial: false},
+		{Languages: []string{"de-DE"}, Imperial: false},
+		{Languages: []string{"en", "en-US"}, Imperial: true},  // bare tag skipped, then -us wins
+		{Languages: []string{"en", "de-DE"}, Imperial: false}, // bare skipped, first regional is metric
+		{Languages: []string{"en"}, Imperial: false},          // bare only → default metric
+		{Languages: []string{"*"}, Imperial: false},           // wildcard ignored → default metric
+		{Languages: []string{}, Imperial: false},              // empty → default metric
+		{Languages: []string{"fr-FR", "en-US"}, Imperial: false}, // first regional (metric) wins
+	}
+	gotLocale, _ := runJSDisplay(t, cases, nil)
+	for _, c := range cases {
+		key := strings.Join(c.Languages, ",")
+		if got := gotLocale[key]; got != c.Imperial {
+			t.Errorf("imperialLengthFromLanguages(%v) = %t, want %t", c.Languages, got, c.Imperial)
+		}
+	}
+}
+
+// TestAltitudeDisplayValue pins how a canonical bare-metres value renders in
+// the altitude field: metric always "<m>m"; imperial shows "<ft>ft" only
+// when it round-trips exactly back to the stored metres, otherwise "<m>m".
+func TestAltitudeDisplayValue(t *testing.T) {
+	cases := []altDisplayCase{
+		// Metric viewer: always metres, unit suffixed.
+		{Metres: "3.6576", Imperial: false, Output: "3.6576m"},
+		{Metres: "20", Imperial: false, Output: "20m"},
+		{Metres: "", Imperial: false, Output: ""},
+		// Imperial viewer, exact whole-feet conversions → feet.
+		{Metres: "3.6576", Imperial: true, Output: "12ft"},   // 12 ft
+		{Metres: "19.812", Imperial: true, Output: "65ft"},   // 65 ft
+		{Metres: "121.92", Imperial: true, Output: "400ft"},  // 400 ft
+		{Metres: "0", Imperial: true, Output: "0ft"},
+		// Imperial viewer, value not a whole number of feet → stays metres.
+		{Metres: "20", Imperial: true, Output: "20m"},   // 65.6168 ft, not exact
+		{Metres: "42.5", Imperial: true, Output: "42.5m"},
+		// Empty passthrough regardless of locale.
+		{Metres: "", Imperial: true, Output: ""},
+	}
+	_, gotAlt := runJSDisplay(t, nil, cases)
+	for _, c := range cases {
+		if got := gotAlt[altKey(c.Metres, c.Imperial)]; got != c.Output {
+			t.Errorf("altitudeDisplayValue(%q, %t) = %q, want %q", c.Metres, c.Imperial, got, c.Output)
+		}
+	}
+}

internal/clientvalidators/testdata/run_js_display.js

@@ -0,0 +1,96 @@
+// run_js_display.js — pins the client-only altitude display + locale
+// helpers shipped in web/assets/app.js. Separate from run_js_validators.js
+// (which covers the JS↔bash validator parity): these two functions have no
+// bash twin, they just need their behaviour locked from drift on the Go
+// side. Extracts the same /* @validator-parity start … end */ block (where
+// altitudeToBareMetres, which altitudeDisplayValue builds on, lives) and
+// exercises imperialLengthFromLanguages + altitudeDisplayValue.
+//
+// Protocol (stdin → stdout, both JSON):
+//   in:  { "localeCases": [{"languages": [<str>...]}],
+//          "altDisplayCases": [{"metres": <str>, "imperial": <bool>}] }
+//   out: { "localeResults": [{"languages": [...], "imperial": <bool>}],
+//          "altDisplayResults": [{"metres": <str>, "imperial": <bool>, "output": <str>}],
+//          "errors": [<str>...] }
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+function die(message) {
+    process.stderr.write(message + "\n");
+    process.exit(2);
+}
+
+if (process.argv.length < 3) {
+    die("usage: node run_js_display.js <path-to-app.js>");
+}
+
+let text;
+try {
+    text = fs.readFileSync(process.argv[2], "utf8");
+} catch (e) {
+    die("read app.js: " + (e && e.message ? e.message : String(e)));
+}
+
+const START = "/* @validator-parity start */";
+const END = "/* @validator-parity end */";
+const startIdx = text.indexOf(START);
+const endIdx = text.indexOf(END);
+if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) {
+    die("parity markers missing or out of order in " + process.argv[2]);
+}
+const block = text.slice(startIdx + START.length, endIdx);
+
+const exportedNames = ["imperialLengthFromLanguages", "altitudeDisplayValue"];
+const moduleSource = '"use strict";\n' + block + "\n" +
+    "module.exports = { " + exportedNames.join(", ") + " };\n";
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "display-parity-"));
+const tmpModulePath = path.join(tmpDir, "block.js");
+let mod;
+try {
+    fs.writeFileSync(tmpModulePath, moduleSource);
+    mod = require(tmpModulePath);
+} catch (e) {
+    die("load display block: " + (e && e.message ? e.message : String(e)));
+} finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) { /* best effort */ }
+}
+
+let request;
+try {
+    request = JSON.parse(fs.readFileSync(0, "utf8"));
+} catch (e) {
+    die("parse stdin JSON: " + (e && e.message ? e.message : String(e)));
+}
+
+const out = { localeResults: [], altDisplayResults: [], errors: [] };
+
+for (const c of request.localeCases || []) {
+    try {
+        out.localeResults.push({
+            languages: c.languages,
+            imperial: Boolean(mod.imperialLengthFromLanguages(c.languages)),
+        });
+    } catch (e) {
+        out.errors.push("imperialLengthFromLanguages(" + JSON.stringify(c.languages) + "): " + (e && e.message ? e.message : String(e)));
+        out.localeResults.push({ languages: c.languages, imperial: false });
+    }
+}
+
+for (const c of request.altDisplayCases || []) {
+    try {
+        out.altDisplayResults.push({
+            metres: c.metres,
+            imperial: Boolean(c.imperial),
+            output: String(mod.altitudeDisplayValue(c.metres, c.imperial)),
+        });
+    } catch (e) {
+        out.errors.push("altitudeDisplayValue(" + JSON.stringify(c.metres) + "," + JSON.stringify(c.imperial) + "): " + (e && e.message ? e.message : String(e)));
+        out.altDisplayResults.push({ metres: c.metres, imperial: Boolean(c.imperial), output: "" });
+    }
+}
+
+process.stdout.write(JSON.stringify(out));