signalk-livedepth-plugin 0.2.1 → 0.3.2

package/public/js/config.js

@@ -0,0 +1,939 @@
+// node_modules/signalk-plotterext-bus/dist/chunk-4JN5YUOC.js
+var BUS_ID = "plotterExt/1";
+var RPC_ERRORS = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  HOST_ERROR: -32e3,
+  TIMEOUT: -32001,
+  CONNECTION_CLOSED: -32002
+};
+var RpcError = class _RpcError extends Error {
+  code;
+  data;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "RpcError";
+    this.code = opts.code ?? RPC_ERRORS.HOST_ERROR;
+    const data = { ...opts.data ?? {} };
+    if (opts.reason !== void 0) data.reason = opts.reason;
+    this.data = Object.keys(data).length > 0 ? data : void 0;
+  }
+  get reason() {
+    return typeof this.data?.reason === "string" ? this.data.reason : void 0;
+  }
+  toErrorObject() {
+    return {
+      code: this.code,
+      message: this.message,
+      ...this.data ? { data: this.data } : {}
+    };
+  }
+  static fromErrorObject(err) {
+    return new _RpcError(err.message, { code: err.code, data: err.data });
+  }
+  /** Normalize any thrown value into an RpcError suitable for the wire. */
+  static from(err) {
+    if (err instanceof _RpcError) return err;
+    if (err instanceof Error) {
+      return new _RpcError(err.message, { code: RPC_ERRORS.INTERNAL_ERROR });
+    }
+    return new _RpcError(String(err), { code: RPC_ERRORS.INTERNAL_ERROR });
+  }
+};
+var EVENT_READY = "bus.ready";
+var EVENT_HANDSHAKE = "bus.handshake";
+function matchesPattern(pattern, name) {
+  if (pattern === name) return true;
+  return match(pattern.split("."), 0, name.split("."), 0);
+}
+function match(p, pi, n, ni) {
+  while (pi < p.length) {
+    const seg = p[pi];
+    if (seg === "**") {
+      if (pi === p.length - 1) return true;
+      for (let skip = ni; skip <= n.length; skip++) {
+        if (match(p, pi + 1, n, skip)) return true;
+      }
+      return false;
+    }
+    if (ni >= n.length) return false;
+    if (seg !== "*" && seg !== n[ni]) return false;
+    pi++;
+    ni++;
+  }
+  return ni === n.length;
+}
+function matchesAny(patterns, name) {
+  for (const pattern of patterns) {
+    if (matchesPattern(pattern, name)) return true;
+  }
+  return false;
+}
+function wrap(msg) {
+  return { bus: BUS_ID, msg };
+}
+function unwrap(data) {
+  if (typeof data !== "object" || data === null) return null;
+  const env = data;
+  if (env.bus !== BUS_ID) return null;
+  return isJsonRpcMessage(env.msg) ? env.msg : null;
+}
+function isJsonRpcMessage(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const m = v;
+  if (m.jsonrpc !== "2.0") return false;
+  if (typeof m.method === "string") {
+    return m.id === void 0 || typeof m.id === "string" || typeof m.id === "number";
+  }
+  const idOk = typeof m.id === "string" || typeof m.id === "number" || m.id === null;
+  if (!idOk) return false;
+  const hasResult = "result" in m;
+  const err = m.error;
+  const hasError = typeof err === "object" && err !== null && typeof err.code === "number" && typeof err.message === "string";
+  return hasResult ? !("error" in m) : hasError;
+}
+function isRequest(msg) {
+  return "method" in msg && "id" in msg && msg.id !== void 0;
+}
+function isNotification(msg) {
+  return "method" in msg && (!("id" in msg) || msg.id === void 0);
+}
+function isResponse(msg) {
+  return !("method" in msg);
+}
+function windowPort(peer, opts = {}) {
+  const listenWindow = opts.listenWindow ?? globalThis;
+  const origin = opts.origin ?? listenWindow.location?.origin ?? "*";
+  return {
+    post(data, transfer) {
+      if (transfer?.length) {
+        peer.postMessage(data, { targetOrigin: origin, transfer });
+      } else {
+        peer.postMessage(data, origin);
+      }
+    },
+    listen(handler) {
+      const fn = (ev) => {
+        if (ev.source !== peer) return;
+        if (origin !== "*" && ev.origin !== origin) return;
+        handler(ev.data);
+      };
+      listenWindow.addEventListener("message", fn);
+      return () => listenWindow.removeEventListener("message", fn);
+    }
+  };
+}
+var DEFAULT_CALL_TIMEOUT_MS = 1e4;
+var BusEndpoint = class {
+  callTimeoutMs;
+  port;
+  unlisten;
+  onError;
+  pending = /* @__PURE__ */ new Map();
+  methods = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Set();
+  idPrefix = Math.random().toString(36).slice(2, 8);
+  seq = 0;
+  closed = false;
+  constructor(opts) {
+    this.port = opts.port;
+    this.callTimeoutMs = opts.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
+    this.onError = opts.onError ?? ((err) => console.warn("[plotterext-bus]", err));
+    this.unlisten = this.port.listen((data) => this.onData(data));
+  }
+  registerMethod(name, handler) {
+    this.methods.set(name, handler);
+  }
+  unregisterMethod(name) {
+    this.methods.delete(name);
+  }
+  /**
+   * Handle incoming notifications whose names match any of the wildcard
+   * patterns. Returns an unsubscribe function. This is local dispatch only;
+   * telling the peer which events to forward is a separate concern
+   * (`events.subscribe`).
+   */
+  onEvent(patterns, fn) {
+    const entry = { patterns, fn };
+    this.eventHandlers.add(entry);
+    return () => this.eventHandlers.delete(entry);
+  }
+  /**
+   * Send a notification (an event) to the peer. `opts.transfer` moves the
+   * listed objects instead of copying them.
+   */
+  notify(method, params, opts = {}) {
+    this.send(
+      { jsonrpc: "2.0", method, ...params !== void 0 ? { params } : {} },
+      opts.transfer
+    );
+  }
+  /**
+   * Call a method on the peer; resolves with its result. `opts.transfer`
+   * moves the listed objects (e.g. an `ImageBitmap` inside `params`) instead
+   * of copying them.
+   */
+  call(method, params, opts = {}) {
+    if (this.closed) {
+      return Promise.reject(
+        new RpcError("Bus endpoint is closed", {
+          code: RPC_ERRORS.CONNECTION_CLOSED,
+          reason: "CLOSED"
+        })
+      );
+    }
+    const id = `${this.idPrefix}-${++this.seq}`;
+    const timeoutMs = opts.timeoutMs ?? this.callTimeoutMs;
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs > 0 ? setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new RpcError(`Call timed out after ${timeoutMs}ms: ${method}`, {
+            code: RPC_ERRORS.TIMEOUT,
+            reason: "TIMEOUT"
+          })
+        );
+      }, timeoutMs) : null;
+      this.pending.set(id, { resolve, reject, timer });
+      this.send(
+        {
+          jsonrpc: "2.0",
+          id,
+          method,
+          ...params !== void 0 ? { params } : {}
+        },
+        opts.transfer
+      );
+    });
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.unlisten();
+    for (const [, p] of this.pending) {
+      if (p.timer) clearTimeout(p.timer);
+      p.reject(
+        new RpcError("Bus endpoint closed", {
+          code: RPC_ERRORS.CONNECTION_CLOSED,
+          reason: "CLOSED"
+        })
+      );
+    }
+    this.pending.clear();
+    this.eventHandlers.clear();
+  }
+  send(msg, transfer) {
+    if (this.closed) return;
+    this.port.post(wrap(msg), transfer);
+  }
+  onData(data) {
+    const msg = unwrap(data);
+    if (!msg) return;
+    if (isResponse(msg)) {
+      this.onResponse(msg);
+    } else if (isRequest(msg)) {
+      void this.onRequest(msg);
+    } else if (isNotification(msg)) {
+      this.onNotification(msg.method, msg.params);
+    }
+  }
+  onResponse(msg) {
+    if (msg.id === null) return;
+    const p = this.pending.get(msg.id);
+    if (!p) return;
+    this.pending.delete(msg.id);
+    if (p.timer) clearTimeout(p.timer);
+    if ("error" in msg) {
+      p.reject(RpcError.fromErrorObject(msg.error));
+    } else {
+      p.resolve(msg.result);
+    }
+  }
+  async onRequest(msg) {
+    const handler = this.methods.get(msg.method);
+    if (!handler) {
+      this.send({
+        jsonrpc: "2.0",
+        id: msg.id,
+        error: {
+          code: RPC_ERRORS.METHOD_NOT_FOUND,
+          message: `Method not found: ${msg.method}`
+        }
+      });
+      return;
+    }
+    try {
+      const result = await handler(msg.params, { endpoint: this });
+      this.send({
+        jsonrpc: "2.0",
+        id: msg.id,
+        result: result === void 0 ? null : result
+      });
+    } catch (err) {
+      this.send({
+        jsonrpc: "2.0",
+        id: msg.id,
+        error: RpcError.from(err).toErrorObject()
+      });
+    }
+  }
+  onNotification(name, params) {
+    for (const entry of [...this.eventHandlers]) {
+      if (matchesAny(entry.patterns, name)) {
+        try {
+          entry.fn(name, params);
+        } catch (err) {
+          this.onError(err);
+        }
+      }
+    }
+  }
+};
+
+// node_modules/signalk-plotterext-bus/dist/chunk-N42ZRM4R.js
+var ExtensionClient = class {
+  handshake;
+  endpoint;
+  constructor(endpoint, handshake) {
+    this.endpoint = endpoint;
+    this.handshake = handshake;
+  }
+  get context() {
+    return this.handshake.context;
+  }
+  get apiVersion() {
+    return this.handshake.apiVersion;
+  }
+  get capabilities() {
+    return this.handshake.capabilities;
+  }
+  hasCapability(id) {
+    return this.handshake.capabilities.includes(id);
+  }
+  /**
+   * Call a host API method. `opts.transfer` moves the listed objects instead
+   * of copying them — only `overlay.frame` needs it in this version.
+   */
+  call(method, params, opts) {
+    return this.endpoint.call(method, params, opts);
+  }
+  /** Send a notification to the host. */
+  notify(method, params) {
+    this.endpoint.notify(method, params);
+  }
+  /**
+   * Subscribe to host events matching wildcard patterns. Registers both the
+   * host-side forwarding subscription and local dispatch; the returned
+   * function tears down both.
+   */
+  async subscribe(patterns, handler) {
+    const off = this.endpoint.onEvent(patterns, handler);
+    let subscriptionId;
+    try {
+      const result = await this.call("events.subscribe", { patterns });
+      subscriptionId = result.subscriptionId;
+    } catch (err) {
+      off();
+      throw err;
+    }
+    return async () => {
+      off();
+      await this.call("events.unsubscribe", { subscriptionId }).catch(() => {
+      });
+    };
+  }
+  /**
+   * Publish an event onto the bus (capability `events.publish`). The host
+   * delivers it to every context in `scope` whose subscriptions match —
+   * including this one — exactly as it delivers host events. `scope` defaults
+   * to `'all'` (any extension); `'extension'` keeps it to this extension's own
+   * contexts. Resolves once the host has delivered it; there is no reply.
+   */
+  async publish(topic, params, scope) {
+    await this.call("events.publish", {
+      topic,
+      ...params !== void 0 ? { params } : {},
+      ...scope ? { scope } : {}
+    });
+  }
+  /** Host-persisted key/value state (see spec: State Storage). */
+  state = {
+    get: async (keys, scope) => {
+      const result = await this.call("state.get", {
+        ...scope ? { scope } : {},
+        ...keys ? { keys } : {}
+      });
+      return result.values ?? {};
+    },
+    set: async (values, scope) => {
+      await this.call("state.set", {
+        ...scope ? { scope } : {},
+        values
+      });
+    }
+  };
+  /** Signal K data relayed by the host (capabilities signalk.stream / .put). */
+  signalk = {
+    /**
+     * Subscribe to Signal K path values. The host publishes them as
+     * `sk.<path>` events; this helper hides the event-name mapping and
+     * establishes both the event-forwarding subscription and the host's
+     * upstream Signal K subscription.
+     */
+    subscribe: async (paths, handler) => {
+      const patterns = paths.map((p) => `sk.${p}`);
+      const offEvents = await this.subscribe(
+        patterns,
+        (_name, params) => handler(params)
+      );
+      let subscriptionId;
+      try {
+        const result = await this.call("signalk.subscribe", { paths });
+        subscriptionId = result.subscriptionId;
+      } catch (err) {
+        await offEvents();
+        throw err;
+      }
+      return async () => {
+        await offEvents();
+        await this.call("signalk.unsubscribe", { subscriptionId }).catch(
+          () => {
+          }
+        );
+      };
+    },
+    put: (path, value) => {
+      return this.call("signalk.put", { path, value });
+    }
+  };
+  /**
+   * The host's visible routes (capability `routes`). Thin **typed** wrappers over
+   * the host's `route.*` methods — each just delegates to `this.call(...)`, so a
+   * plain-JS extension can call `client.call('route.replace', …)` directly and a
+   * TypeScript extension gets the typed `client.route.replace(…)` sugar with no
+   * behavioural difference. Follow lifecycle + mutations by subscribing to
+   * `route.**` events (`RouteVisibleEvent` / `RouteDirtyEvent` / `RouteSavedEvent`
+   * / `RouteHiddenEvent`). Further operations (rename/point ops) extend this
+   * surface as the capability fills out.
+   */
+  route = {
+    list: async () => {
+      const result = await this.call("route.list");
+      return result.routes ?? [];
+    },
+    create: async (opts) => {
+      return await this.call("route.create", opts);
+    },
+    get: async (routeId) => {
+      return await this.call("route.get", { routeId });
+    },
+    replace: async (routeId, points) => {
+      return await this.call("route.replace", { routeId, points });
+    },
+    save: async (routeId, opts) => {
+      return await this.call("route.save", {
+        routeId,
+        ...opts ?? {}
+      });
+    },
+    show: async (ref) => {
+      return await this.call("route.show", { ref });
+    },
+    hide: async (routeId) => {
+      await this.call("route.hide", { routeId });
+    },
+    delete: async (routeId) => {
+      await this.call("route.delete", { routeId });
+    }
+  };
+  /**
+   * The host's chart layers (capability `charts`). Thin **typed** wrappers over
+   * the host's `chart.*` methods — a lightweight facade over the charts the host
+   * already manages: enumerate them, toggle visibility, opacity and stacking
+   * order (all batch). It does not create, add, or delete chart sources. Follow
+   * changes (from any origin, including the host's own chart controls) by
+   * subscribing to `chart.**` events (`ChartVisibilityEvent` / `ChartOpacityEvent`
+   * / `ChartOrderEvent` / `ChartTimeEvent`) and re-reading `chart.list` where
+   * needed. As with every wrapper, a plain-JS extension can call
+   * `client.call('chart.list', …)` directly with no behavioural difference.
+   */
+  chart = {
+    list: async () => {
+      const result = await this.call("chart.list");
+      return result.charts ?? [];
+    },
+    setVisibility: async (ids, visible) => {
+      await this.call("chart.setVisibility", { ids, visible });
+    },
+    setOpacity: async (ids, opacity) => {
+      await this.call("chart.setOpacity", { ids, opacity });
+    },
+    setOrder: async (order) => {
+      await this.call("chart.setOrder", { order });
+    },
+    /**
+     * Retarget time-varying charts to an ISO 8601 instant, or back to their
+     * live frame with `null` (sub-capability `charts.time`). Follow changes via
+     * the `chart.time` event (`ChartTimeEvent`).
+     */
+    setTime: async (ids, time) => {
+      await this.call("chart.setTime", { ids, time });
+    }
+  };
+  /**
+   * The host's night-vision display mode (capability `nightMode`). Read the
+   * current `{ enabled, auto }` state, change it, and follow changes by
+   * subscribing to the `nightMode.changed` event (`NightModeChangedEvent`).
+   * `set` expresses the three states the spec defines: force on
+   * (`{ enabled: true }`), force off (`{ enabled: false }`), follow the server
+   * (`{ auto: true }`); setting `enabled` implies `auto: false`. As with every
+   * wrapper, a plain-JS extension can call `client.call('nightMode.get' |
+   * 'nightMode.set', …)` directly with no behavioural difference.
+   */
+  nightMode = {
+    get: async () => {
+      return await this.call("nightMode.get");
+    },
+    set: async (state) => {
+      await this.call("nightMode.set", state);
+    }
+  };
+  /**
+   * Panel visibility (capability `panels.state`): the state of each of this
+   * extension's loaded panels. Follow changes with the `panel.state` event,
+   * which every context of the extension receives; subscribe first, then
+   * `list()`, so no change is missed. A plain-JS extension can call
+   * `client.call('ui.listPanels')` with no behavioural difference.
+   */
+  panels = {
+    list: async () => {
+      const r = await this.call("ui.listPanels");
+      return r.panels;
+    }
+  };
+  /**
+   * Image map overlays (capability `overlays.image`): map layers this
+   * extension's background runtime draws. The host asks for frames with the
+   * `overlay.request` event (`OverlayRequestEvent`) and reports visibility
+   * with `overlay.state` (`OverlayStateEvent`); the runtime answers each
+   * request with `frame()`, keeping one frame in flight. `frame()` transfers
+   * `image`, so the caller no longer owns it afterwards. A plain-JS extension
+   * can call `client.call('overlay.frame', params, { transfer: [image] })`
+   * with no behavioural difference.
+   */
+  overlays = {
+    list: async () => {
+      const r = await this.call("overlay.list");
+      return r.overlays;
+    },
+    setVisibility: async (ids, visible) => {
+      await this.call("overlay.setVisibility", { ids, visible });
+    },
+    setOpacity: async (ids, opacity) => {
+      await this.call("overlay.setOpacity", { ids, opacity });
+    },
+    frame: async (params) => {
+      return await this.call("overlay.frame", params, {
+        transfer: [params.image]
+      });
+    }
+  };
+  /**
+   * Floating windows (capability `windows`): show one of this extension's
+   * iframe panels in a window over the chart. Geometry is a request — read the
+   * actual `bounds` from the returned `WindowState`, and follow changes with
+   * the `window.bounds` / `window.state` / `window.closed` events. Windows
+   * belong to the extension, so any of its contexts may manage them; in a
+   * `window` context, `update` / `focus` / `close` default to the window
+   * itself when `windowId` is left out. A plain-JS extension can call
+   * `client.call('ui.openWindow', …)` and friends directly with no
+   * behavioural difference.
+   */
+  windows = {
+    open: async (params) => {
+      return await this.call("ui.openWindow", params);
+    },
+    update: async (params) => {
+      return await this.call("ui.updateWindow", params);
+    },
+    focus: async (windowId) => {
+      await this.call("ui.focusWindow", windowId === void 0 ? {} : { windowId });
+    },
+    close: async (windowId) => {
+      await this.call("ui.closeWindow", windowId === void 0 ? {} : { windowId });
+    },
+    list: async () => {
+      const r = await this.call("ui.listWindows");
+      return r.windows;
+    }
+  };
+  /**
+   * Apply a stored resource group to the host's display (capability
+   * `resourceGroups`). Resolves to `{ applied }` — the types the host made a
+   * best-effort attempt to carry out; a type it did not act on is omitted.
+   * Follow applies from any origin (including the user's own group picker) via
+   * the `resourceGroup.applied` event (`ResourceGroupAppliedEvent`). Group CRUD
+   * is not here: use the server's resources API (`/resources/groups`). A
+   * plain-JS extension can call `client.call('resourceGroup.apply', { id })`
+   * directly with no behavioural difference.
+   */
+  resourceGroup = {
+    apply: async (id) => {
+      return await this.call("resourceGroup.apply", {
+        id
+      });
+    }
+  };
+  /**
+   * The host's chart viewport (capability `map`). Read the current
+   * `{ center, zoom, bounds }`, drive it, and follow it by subscribing to the
+   * `map.view` event (`MapViewEvent`), which carries the same shape and fires
+   * once per settled pan/zoom. Seed with `getView` so a follower has a view
+   * before the first change. As with every wrapper, a plain-JS extension can
+   * call `client.call('map.getView' | 'map.center' | 'map.fitBounds', …)`
+   * directly with no behavioural difference.
+   */
+  map = {
+    getView: async () => {
+      return await this.call("map.getView");
+    },
+    center: async (position, zoom) => {
+      await this.call("map.center", {
+        position,
+        ...typeof zoom === "number" ? { zoom } : {}
+      });
+    },
+    /**
+     * Fit the chart to `[west, south, east, north]`. A box crossing the
+     * antimeridian may be given as `west > east` (the API's form) or unwrapped
+     * (`east` past 180); the host fits it the short way round.
+     */
+    fitBounds: async (bounds) => {
+      await this.call("map.fitBounds", { bounds });
+    }
+  };
+  close() {
+    this.endpoint.close();
+  }
+};
+function connectExtension(opts = {}) {
+  const port = opts.port ?? windowPort(globalThis.parent, {
+    origin: "*"
+  });
+  const endpoint = new BusEndpoint({
+    port,
+    callTimeoutMs: opts.callTimeoutMs,
+    onError: opts.onError
+  });
+  const readyParams = opts.id ? { id: opts.id } : void 0;
+  return new Promise((resolve, reject) => {
+    let done = false;
+    const off = endpoint.onEvent([EVENT_HANDSHAKE], (_name, params) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      resolve(new ExtensionClient(endpoint, params));
+    });
+    const interval = setInterval(
+      () => endpoint.notify(EVENT_READY, readyParams),
+      opts.readyIntervalMs ?? 250
+    );
+    const timeout = setTimeout(() => {
+      if (done) return;
+      done = true;
+      cleanup();
+      endpoint.close();
+      reject(
+        new RpcError("Timed out waiting for host handshake", {
+          code: RPC_ERRORS.TIMEOUT,
+          reason: "HANDSHAKE_TIMEOUT"
+        })
+      );
+    }, opts.timeoutMs ?? 1e4);
+    const cleanup = () => {
+      off();
+      clearInterval(interval);
+      clearTimeout(timeout);
+    };
+    endpoint.notify(EVENT_READY, readyParams);
+  });
+}
+
+// src/web/shared/settings.ts
+var DEFAULT_SETTINGS = {
+  enabled: true,
+  source: "history",
+  quality: "auto",
+  historyWindowHours: 1,
+  historyResolutionS: 0.1,
+  shadeLimitMetres: 10,
+  contourIntervalMetres: 1,
+  cellPx: 24,
+  mergeTolerance: 0.15,
+  maxDepthMetres: 100,
+  safetyDepthMetres: 3
+};
+var ENUM_VALUES = {
+  source: ["history", "tiles"],
+  quality: ["auto", "high", "balanced", "low"]
+};
+var SETTINGS_BOUNDS = {
+  historyWindowHours: { min: 0.1, max: 168, step: 0.1 },
+  historyResolutionS: { min: 0.01, max: 60, step: 0.01 },
+  shadeLimitMetres: { min: 1, max: 200, step: 1 },
+  contourIntervalMetres: { min: 0.5, max: 50, step: 0.5 },
+  cellPx: { min: 4, max: 128, step: 1 },
+  mergeTolerance: { min: 0, max: 1, step: 0.01 },
+  maxDepthMetres: { min: 1, max: 500, step: 1 },
+  safetyDepthMetres: { min: 0, max: 50, step: 0.5 }
+};
+function mergeSettings(stored) {
+  const out = { ...DEFAULT_SETTINGS };
+  if (!stored) {
+    return out;
+  }
+  for (const key of Object.keys(
+    DEFAULT_SETTINGS
+  )) {
+    const value = stored[key];
+    if (typeof value !== typeof DEFAULT_SETTINGS[key]) {
+      continue;
+    }
+    const allowed = ENUM_VALUES[key];
+    if (allowed && !allowed.includes(value)) {
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+// src/web/config.ts
+var METRES_PER_FOOT = 0.3048;
+var client = await connectExtension();
+var settings = { ...DEFAULT_SETTINGS };
+var depthUnit = "m";
+var root = document.getElementById("root");
+var FIELDS = [
+  {
+    key: "historyWindowHours",
+    label: "History window",
+    hint: "How far back to fetch depth.",
+    suffix: "h",
+    historyOnly: true
+  },
+  {
+    key: "historyResolutionS",
+    label: "Sample interval",
+    hint: "Seconds between depth samples; smaller is finer.",
+    suffix: "s",
+    historyOnly: true
+  },
+  {
+    key: "shadeLimitMetres",
+    label: "Shade limit",
+    hint: "Depth the shading runs to; deeper is left to the chart.",
+    depth: true
+  },
+  {
+    key: "contourIntervalMetres",
+    label: "Isobath interval",
+    hint: "Depth between isobaths.",
+    depth: true
+  },
+  {
+    key: "cellPx",
+    label: "Grid cell",
+    hint: "Circle diameter, in screen pixels.",
+    suffix: "px"
+  },
+  {
+    key: "mergeTolerance",
+    label: "Merge band",
+    hint: "Adjacent positions within this depth fraction merge into one circle."
+  },
+  {
+    key: "maxDepthMetres",
+    label: "Max depth",
+    hint: "Samples deeper than this are not drawn.",
+    depth: true
+  },
+  {
+    key: "safetyDepthMetres",
+    label: "Safety depth",
+    hint: "Samples at or below this depth are marked individually.",
+    depth: true
+  }
+];
+var unitSymbol = () => depthUnit === "foot" ? "ft" : "m";
+var toDisplay = (metres) => depthUnit === "foot" ? metres / METRES_PER_FOOT : metres;
+var fromDisplay = (value) => depthUnit === "foot" ? value * METRES_PER_FOOT : value;
+var round = (v) => Math.round(v * 100) / 100;
+var historyRows = [];
+var historyInputs = [];
+function syncHistoryDisabled() {
+  const disabled = settings.source === "tiles";
+  for (const input of historyInputs) {
+    input.disabled = disabled;
+  }
+  for (const row of historyRows) {
+    row.classList.toggle("disabled", disabled);
+  }
+}
+function displayBounds(field) {
+  const b = SETTINGS_BOUNDS[field.key];
+  if (!field.depth || depthUnit !== "foot") {
+    return b;
+  }
+  return {
+    min: Math.floor(toDisplay(b.min)),
+    max: Math.round(toDisplay(b.max)),
+    step: 1
+  };
+}
+function numberField(field) {
+  const { min: lo, max: hi, step } = displayBounds(field);
+  const wrap2 = document.createElement("label");
+  wrap2.className = "field";
+  const name = document.createElement("span");
+  name.className = "name";
+  name.textContent = field.label;
+  wrap2.appendChild(name);
+  const control = document.createElement("span");
+  control.className = "control";
+  const input = document.createElement("input");
+  input.type = "number";
+  input.min = `${lo}`;
+  input.max = `${hi}`;
+  input.step = `${step}`;
+  const stored = settings[field.key];
+  input.value = `${round(field.depth ? toDisplay(stored) : stored)}`;
+  input.addEventListener("change", () => {
+    const clamped = Math.min(hi, Math.max(lo, Number(input.value)));
+    input.value = `${round(clamped)}`;
+    settings[field.key] = field.depth ? fromDisplay(clamped) : clamped;
+    void save();
+  });
+  control.appendChild(input);
+  const suffix = document.createElement("span");
+  suffix.className = "suffix";
+  suffix.textContent = field.depth ? unitSymbol() : field.suffix ?? "";
+  control.appendChild(suffix);
+  wrap2.appendChild(control);
+  if (field.hint) {
+    const hint = document.createElement("span");
+    hint.className = "hint";
+    hint.textContent = field.hint;
+    wrap2.appendChild(hint);
+  }
+  if (field.historyOnly) {
+    historyRows.push(wrap2);
+    historyInputs.push(input);
+  }
+  return wrap2;
+}
+function build() {
+  root.replaceChildren();
+  historyRows.length = 0;
+  historyInputs.length = 0;
+  const heading = document.createElement("h2");
+  heading.textContent = "LiveDepth";
+  root.appendChild(heading);
+  const enabled = document.createElement("label");
+  enabled.className = "field row";
+  const enabledName = document.createElement("span");
+  enabledName.className = "name";
+  enabledName.textContent = "Show the layer";
+  const enabledInput = document.createElement("input");
+  enabledInput.type = "checkbox";
+  enabledInput.checked = settings.enabled;
+  enabledInput.addEventListener("change", () => {
+    settings.enabled = enabledInput.checked;
+    void save();
+  });
+  enabled.append(enabledName, enabledInput);
+  root.appendChild(enabled);
+  const source = document.createElement("label");
+  source.className = "field";
+  const sourceName = document.createElement("span");
+  sourceName.className = "name";
+  sourceName.textContent = "Depth source";
+  const select = document.createElement("select");
+  for (const [value, label] of [
+    ["history", "History (this vessel's track)"],
+    ["tiles", "LiveDepth plugin tiles"]
+  ]) {
+    const option = document.createElement("option");
+    option.value = value;
+    option.textContent = label;
+    option.selected = settings.source === value;
+    select.appendChild(option);
+  }
+  select.addEventListener("change", () => {
+    settings.source = select.value;
+    syncHistoryDisabled();
+    void save();
+  });
+  source.append(sourceName, select);
+  const sourceHint = document.createElement("span");
+  sourceHint.className = "hint";
+  sourceHint.textContent = "History draws the vessel's own recorded track; tiles draw the server-built bathymetry store, extended live.";
+  source.appendChild(sourceHint);
+  root.appendChild(source);
+  const quality = document.createElement("label");
+  quality.className = "field";
+  const qualityName = document.createElement("span");
+  qualityName.className = "name";
+  qualityName.textContent = "Render quality";
+  const qualitySelect = document.createElement("select");
+  for (const [value, label] of [
+    ["auto", "Auto (adapt to this GPU)"],
+    ["high", "High"],
+    ["balanced", "Balanced"],
+    ["low", "Low"]
+  ]) {
+    const option = document.createElement("option");
+    option.value = value;
+    option.textContent = label;
+    option.selected = settings.quality === value;
+    qualitySelect.appendChild(option);
+  }
+  qualitySelect.addEventListener("change", () => {
+    settings.quality = qualitySelect.value;
+    void save();
+  });
+  quality.append(qualityName, qualitySelect);
+  const qualityHint = document.createElement("span");
+  qualityHint.className = "hint";
+  qualityHint.textContent = "Scales the shaded depth surface only; soundings, circles and labels always render at full resolution. Auto adapts to this GPU.";
+  quality.appendChild(qualityHint);
+  root.appendChild(quality);
+  for (const field of FIELDS) {
+    root.appendChild(numberField(field));
+  }
+  syncHistoryDisabled();
+}
+async function save() {
+  await client.state.set(settings);
+}
+async function load() {
+  try {
+    settings = mergeSettings(
+      await client.state.get()
+    );
+  } catch {
+    settings = { ...DEFAULT_SETTINGS };
+  }
+  try {
+    const res = await client.call("units.get");
+    depthUnit = res?.units?.depth === "foot" ? "foot" : "m";
+  } catch {
+    depthUnit = "m";
+  }
+  build();
+}
+await load();
+//# sourceMappingURL=config.js.map