@sukramj/fabric-ui 0.1.2 → 0.2.0

package/src/lib/api/stream.ts

@@ -1,6 +1,6 @@
 // The event stream helper: GET /node/stream as typed callbacks. A host with
 // a hub of its own feeds it from here (see ui/README.md).
-import type { ExposureEvent, FabricEvent, WindowEvent } from "./client";
+import type { ControllerEvent, ExposureEvent, FabricEvent, WindowEvent } from "./client";
 
 /** The event types of the stream, as the contract names them. */
 export const STREAM_EVENTS = [
@@ -52,3 +52,42 @@ export function subscribeStream(
   }
   return () => es.close();
 }
+
+/** The event types of the controller stream (GET /controller/stream). */
+export const CONTROLLER_STREAM_EVENTS = [
+  "node_added",
+  "node_updated",
+  "node_removed",
+  "connection",
+  "subscription",
+  "commissioning_progress",
+  "update",
+] as const;
+
+export type ControllerStreamEventType = (typeof CONTROLLER_STREAM_EVENTS)[number];
+
+export type ControllerStreamEvent = { type: ControllerStreamEventType; data: ControllerEvent };
+
+/**
+ * Subscribes to the controller stream at `url`, as subscribeStream does
+ * for the node's. Returns the close function.
+ */
+export function subscribeControllerStream(
+  url: string,
+  onEvent: (ev: ControllerStreamEvent) => void,
+  open: EventSourceFactory = (u) => new EventSource(u, { withCredentials: true }),
+): () => void {
+  const es = open(url);
+  for (const type of CONTROLLER_STREAM_EVENTS) {
+    es.addEventListener(type, (msg: MessageEvent) => {
+      let data: unknown;
+      try {
+        data = JSON.parse(String(msg.data));
+      } catch {
+        return;
+      }
+      onEvent({ type, data: data as ControllerEvent });
+    });
+  }
+  return () => es.close();
+}

package/src/lib/context.ts

@@ -1,11 +1,12 @@
 // The fabric-ui context: what every page reads — the client, the host's
-// translator, toast and confirm, the node store and the links between the
-// pages. A host provides it once above the pages (provideFabricUI); the
+// translator, toast and confirm, the node and controller stores and the
+// links between the pages. A host provides it once above the pages (provideFabricUI); the
 // standalone shell provides its own.
 import { getContext, hasContext, setContext } from "svelte";
 import type { FabricClient } from "./api/client";
 import { defaultT, type Translate } from "./i18n";
 import { createNodeStore, type NodeStore, type NodeStoreDeps, type Toast } from "./store.svelte";
+import { createControllerStore, type ControllerStore, type ControllerStoreDeps } from "./controller-store.svelte";
 
 export type { Toast } from "./store.svelte";
 
@@ -26,6 +27,11 @@ export interface Routes {
   selection: string;
   endpoints: string;
   diagnostics: string;
+  controllerNodes: string;
+  controllerCommission: string;
+  controllerSettings: string;
+  /** The prefix of one node's page; the page appends the node's 16-digit hex id. */
+  controllerNode: string;
 }
 
 export const defaultRoutes: Routes = {
@@ -35,6 +41,10 @@ export const defaultRoutes: Routes = {
   selection: "#/node/selection",
   endpoints: "#/node/endpoints",
   diagnostics: "#/node/diagnostics",
+  controllerNodes: "#/controller/nodes",
+  controllerCommission: "#/controller/commission",
+  controllerSettings: "#/controller/settings",
+  controllerNode: "#/controller/node/",
 };
 
 export interface FabricUI {
@@ -43,6 +53,7 @@ export interface FabricUI {
   toast: Toast;
   confirm: Confirm;
   node: NodeStore;
+  controller: ControllerStore;
   routes: Routes;
 }
 
@@ -53,6 +64,7 @@ export interface FabricUIOptions {
   confirm?: Confirm;
   routes?: Partial<Routes>;
   subscribe?: NodeStoreDeps["subscribe"];
+  subscribeController?: ControllerStoreDeps["subscribe"];
 }
 
 const KEY = Symbol.for("@sukramj/fabric-ui");
@@ -73,6 +85,7 @@ export function createFabricUI(opts: FabricUIOptions): FabricUI {
     toast,
     confirm: opts.confirm ?? (async (o) => window.confirm(o.body ? `${o.title}\n\n${o.body}` : o.title)),
     node: createNodeStore(opts.client, { t, toast, subscribe: opts.subscribe }),
+    controller: createControllerStore(opts.client, { t, toast, subscribe: opts.subscribeController }),
     routes: { ...defaultRoutes, ...opts.routes },
   };
 }

package/src/lib/controller-store.svelte.ts

@@ -0,0 +1,175 @@
+// The controller family's state: the controller's status, the node list,
+// the credentials and the update queue, and the progress of a
+// commissioning, kept current by the controller stream. One instance per
+// fabric-ui context, as the node store.
+import {
+  ApiError,
+  type ControllerNodeSummary,
+  type ControllerStatus,
+  type Credential,
+  type FabricClient,
+  type UpdateQueue,
+} from "./api/client";
+import { subscribeControllerStream, type ControllerStreamEvent } from "./api/stream";
+import type { Toast } from "./store.svelte";
+import type { Translate } from "./i18n";
+
+export type CommissionPhase = "idle" | "started" | "succeeded" | "failed";
+
+export interface CommissionProgress {
+  phase: CommissionPhase;
+  /** The failure's kind (no_device, timeout, …) of a failed commissioning. */
+  detail: string | null;
+  /** The node a succeeded commissioning added. */
+  nodeIdHex: string | null;
+}
+
+export interface ControllerStoreDeps {
+  t: Translate;
+  toast: Toast;
+  /** Subscribes to the controller stream; the default opens an EventSource on the client's URL. */
+  subscribe?: (onEvent: (ev: ControllerStreamEvent) => void) => () => void;
+}
+
+const IDLE: CommissionProgress = { phase: "idle", detail: null, nodeIdHex: null };
+
+/** How long the store waits before reloading after an event, so a burst reloads once. */
+const RELOAD_DELAY = 250;
+
+export function createControllerStore(client: FabricClient, deps: ControllerStoreDeps) {
+  let status = $state<ControllerStatus | null>(null);
+  // null until probed; false when the host serves no controller (404).
+  let present = $state<boolean | null>(null);
+  let statusError = $state<string | null>(null);
+  let nodes = $state<ControllerNodeSummary[]>([]);
+  let nodesLoading = $state(false);
+  let nodesError = $state<string | null>(null);
+  let credentials = $state<Credential[]>([]);
+  let credentialsError = $state<string | null>(null);
+  let updates = $state<UpdateQueue | null>(null);
+  let progress = $state<CommissionProgress>({ ...IDLE });
+  // Bumped on every event about a node, so an open node page reloads.
+  let revision = $state(0);
+  let changed = $state<string | null>(null);
+
+  let unsub: (() => void) | null = null;
+  let reload: ReturnType<typeof setTimeout> | null = null;
+
+  const message = (err: unknown) => (err instanceof Error ? err.message : String(err));
+
+  /** Reads the status; a 404 marks the family absent, not an error. */
+  async function loadStatus() {
+    statusError = null;
+    try {
+      status = await client.controllerStatus();
+      present = true;
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404) {
+        present = false;
+        status = null;
+        return;
+      }
+      statusError = message(err);
+    }
+  }
+
+  async function loadNodes() {
+    nodesLoading = true;
+    nodesError = null;
+    try {
+      nodes = (await client.controllerNodes()).nodes;
+    } catch (err) {
+      nodesError = message(err);
+    } finally {
+      nodesLoading = false;
+    }
+  }
+
+  async function loadCredentials() {
+    credentialsError = null;
+    try {
+      credentials = (await client.credentials()).credentials;
+    } catch (err) {
+      credentialsError = message(err);
+    }
+  }
+
+  async function loadUpdates() {
+    try {
+      updates = await client.updates();
+    } catch (err) {
+      deps.toast.error(message(err));
+    }
+  }
+
+  function scheduleReload() {
+    if (reload) return;
+    reload = setTimeout(() => {
+      reload = null;
+      void loadNodes();
+      void loadStatus();
+    }, RELOAD_DELAY);
+  }
+
+  function applyEvent(ev: ControllerStreamEvent) {
+    switch (ev.type) {
+      case "commissioning_progress": {
+        const phase = (ev.data.phase ?? "started") as CommissionPhase;
+        progress = { phase, detail: ev.data.detail ?? null, nodeIdHex: ev.data.node_id_hex ?? null };
+        if (phase === "succeeded") scheduleReload();
+        break;
+      }
+      case "update":
+        void loadUpdates();
+        break;
+      default:
+        changed = ev.data.node_id_hex ?? null;
+        revision++;
+        scheduleReload();
+    }
+  }
+
+  function resetProgress() {
+    progress = { ...IDLE };
+  }
+
+  function connect() {
+    if (unsub) return;
+    const sub = deps.subscribe ?? ((fn) => subscribeControllerStream(client.controllerStreamUrl(), fn));
+    unsub = sub(applyEvent);
+  }
+
+  function close() {
+    if (reload) clearTimeout(reload);
+    reload = null;
+    unsub?.();
+    unsub = null;
+  }
+
+  return {
+    get status() { return status; },
+    get present() { return present; },
+    get statusError() { return statusError; },
+    get nodes() { return nodes; },
+    get nodesLoading() { return nodesLoading; },
+    get nodesError() { return nodesError; },
+    get credentials() { return credentials; },
+    get credentialsError() { return credentialsError; },
+    get updates() { return updates; },
+    get progress() { return progress; },
+    /** Counts the events about nodes; a node page reloads when it moves. */
+    get revision() { return revision; },
+    /** The node the last event named. */
+    get changed() { return changed; },
+    loadStatus,
+    loadNodes,
+    loadCredentials,
+    loadUpdates,
+    applyEvent,
+    resetProgress,
+    connect,
+    close,
+  };
+}
+
+export type ControllerStore = ReturnType<typeof createControllerStore>;

package/src/lib/i18n/de.json

@@ -12,6 +12,213 @@
   "common.save": "Speichern",
   "common.saving": "Wird gespeichert…",
   "common.search": "Suchen…",
+  "controller.acl.add": "Eintrag hinzufügen",
+  "controller.acl.add_entry": "Hinzufügen",
+  "controller.acl.any_subject": "jedes Subjekt",
+  "controller.acl.discard": "Verwerfen",
+  "controller.acl.empty": "Kein Eintrag der Fabric dieses Controllers",
+  "controller.acl.invalid_subject": "Ein Subjekt ist keine hexadezimale ID.",
+  "controller.acl.invalid_target": "Der Cluster ist keine hexadezimale ID.",
+  "controller.acl.lockout": "Diesen Controller aussperren?",
+  "controller.acl.lockout_body": "Die Liste hat keinen Administer-Eintrag für diesen Controller; nach dem Schreiben kann er den Knoten nicht mehr ändern.",
+  "controller.acl.mode.case": "CASE",
+  "controller.acl.mode.group": "Gruppe",
+  "controller.acl.mode.pase": "PASE",
+  "controller.acl.mode_label": "Authentifizierung",
+  "controller.acl.privilege.administer": "Administrieren",
+  "controller.acl.privilege.manage": "Verwalten",
+  "controller.acl.privilege.operate": "Bedienen",
+  "controller.acl.privilege.proxy_view": "Proxy-Ansicht",
+  "controller.acl.privilege.view": "Ansehen",
+  "controller.acl.privilege_label": "Berechtigung",
+  "controller.acl.saved": "Die ACL ist geschrieben.",
+  "controller.acl.subjects": "Subjekte (hex, durch Komma getrennt)",
+  "controller.acl.target_cluster": "Cluster (hex)",
+  "controller.acl.target_endpoint": "Endpoint",
+  "controller.acl.whole_node": "der ganze Knoten",
+  "controller.attributes.attribute": "Attribut-ID",
+  "controller.attributes.cluster": "Cluster",
+  "controller.attributes.endpoint": "Endpoint",
+  "controller.attributes.hint": "Ein Attribut lesen: Endpoint und Cluster wählen, die Attribut-ID hexadezimal angeben.",
+  "controller.attributes.invalid_json": "Der Wert ist kein JSON.",
+  "controller.attributes.invalid_path": "Cluster- oder Attribut-ID ist nicht hexadezimal.",
+  "controller.attributes.read": "Lesen",
+  "controller.attributes.status": "Der Knoten antwortete mit Status {status}.",
+  "controller.attributes.value": "Wert als JSON",
+  "controller.attributes.write": "Schreiben",
+  "controller.attributes.write_status": "Der Knoten lehnte das Schreiben ab: Status {status}.",
+  "controller.attributes.written": "Geschrieben.",
+  "controller.bindings.add": "Hinzufügen",
+  "controller.bindings.cluster": "Cluster (hex)",
+  "controller.bindings.empty": "Kein Binding",
+  "controller.bindings.endpoint": "Endpoint",
+  "controller.bindings.group": "Gruppe {group}",
+  "controller.bindings.invalid": "Ein Ziel ist eine Node-ID mit Endpoint oder g: mit einer Gruppen-ID.",
+  "controller.bindings.none": "Der Knoten hat keinen Binding-Cluster",
+  "controller.bindings.saved": "Die Bindings sind geschrieben.",
+  "controller.bindings.target": "Node-ID (hex) oder g:<Gruppe>",
+  "controller.commission.by_code": "Kopplungscode",
+  "controller.commission.by_code_hint": "QR-Inhalt (MT:…) oder den auf dem Gerät gedruckten manuellen Kopplungscode eingeben.",
+  "controller.commission.code": "Kopplungscode",
+  "controller.commission.code_placeholder": "MT:… oder 11 Ziffern",
+  "controller.commission.col_addresses": "Adressen",
+  "controller.commission.col_device": "Gerät",
+  "controller.commission.col_discriminator": "Diskriminator",
+  "controller.commission.col_vendor": "Hersteller",
+  "controller.commission.discovery": "Geräte im Netz",
+  "controller.commission.done": "{name} ist gekoppelt.",
+  "controller.commission.failed": "Kopplung fehlgeschlagen",
+  "controller.commission.network": "Netz für das Gerät",
+  "controller.commission.network_none": "Keine Netz-Zugangsdaten",
+  "controller.commission.network_only": "Nur über das Netz (kein Bluetooth)",
+  "controller.commission.none_found": "Kein koppelbares Gerät hat geantwortet",
+  "controller.commission.pair": "Koppeln",
+  "controller.commission.passcode": "PIN",
+  "controller.commission.passcode_invalid": "Die PIN liegt zwischen 1 und 99999998.",
+  "controller.commission.running": "Kopplung läuft…",
+  "controller.commission.search": "Suchen",
+  "controller.commission.searching": "Suche läuft…",
+  "controller.commission.start": "Koppeln",
+  "controller.commission.succeeded": "Gekoppelt",
+  "controller.connection.connected": "Verbunden",
+  "controller.connection.disconnected": "Getrennt",
+  "controller.connection.reconnecting": "Verbindet neu",
+  "controller.connection.waiting_for_discovery": "Wartet auf Erkennung",
+  "controller.credential.kind_thread": "Thread",
+  "controller.credential.kind_wifi": "WLAN",
+  "controller.endpoints.empty": "Der Controller kennt noch keinen Endpoint dieses Knotens",
+  "controller.endpoints.endpoint": "Endpoint {number}",
+  "controller.fabrics.col_fabric_id": "Fabric-ID",
+  "controller.fabrics.own": "dieser Controller",
+  "controller.fabrics.remove_confirm": "Die Fabric dieses Administrators vom Knoten entfernen?",
+  "controller.fabrics.removed": "Die Fabric ist entfernt.",
+  "controller.icd.awake": "Wach",
+  "controller.icd.forget": "Ohne den Knoten vergessen",
+  "controller.icd.last_check_in": "Letzter Check-in",
+  "controller.icd.lit_supported": "Unterstützt LIT",
+  "controller.icd.mode.lit": "LIT",
+  "controller.icd.mode.sit": "SIT",
+  "controller.icd.multi_admin": "Trotz anderer Administratoren registrieren?",
+  "controller.icd.next_check_in": "Nächster Check-in",
+  "controller.icd.register": "Registrieren",
+  "controller.icd.registered": "Registriert",
+  "controller.icd.registered_done": "Dieser Controller ist registriert.",
+  "controller.icd.unavailable": "Check-in überfällig",
+  "controller.icd.unregister": "Abmelden",
+  "controller.icd.unregistered": "Nicht registriert",
+  "controller.icd.unregistered_done": "Dieser Controller ist abgemeldet.",
+  "controller.icd.unsupported": "Der Knoten ist kein zeitweise verbundenes Gerät",
+  "controller.node.back": "Alle Knoten",
+  "controller.node.tab.acl": "ACL",
+  "controller.node.tab.attributes": "Attribute",
+  "controller.node.tab.bindings": "Bindings",
+  "controller.node.tab.endpoints": "Endpoints",
+  "controller.node.tab.fabrics": "Fabrics",
+  "controller.node.tab.icd": "ICD",
+  "controller.node.tab.overview": "Übersicht",
+  "controller.node.tab.updates": "Updates",
+  "controller.node.tab.window": "Fenster",
+  "controller.node.tabs": "Bereiche des Knotens",
+  "controller.nodes.col_addresses": "Adressen",
+  "controller.nodes.col_connection": "Verbindung",
+  "controller.nodes.col_name": "Knoten",
+  "controller.nodes.col_node_id": "Node-ID",
+  "controller.nodes.col_vendor": "Hersteller",
+  "controller.nodes.commission": "Gerät koppeln",
+  "controller.nodes.disable": "Deaktivieren",
+  "controller.nodes.disabled": "Deaktiviert",
+  "controller.nodes.disabled_done": "Der Knoten ist deaktiviert.",
+  "controller.nodes.empty": "Noch kein Knoten gekoppelt",
+  "controller.nodes.enable": "Aktivieren",
+  "controller.nodes.enabled": "Der Knoten ist aktiviert.",
+  "controller.nodes.filter_all": "Alle",
+  "controller.nodes.filter_connection": "Nach Verbindung filtern",
+  "controller.nodes.filter_icd": "Nach ICD filtern",
+  "controller.nodes.filter_vendor": "Nach Hersteller filtern",
+  "controller.nodes.icd": "ICD",
+  "controller.nodes.icd_no": "Kein ICD",
+  "controller.nodes.icd_yes": "Nur ICD",
+  "controller.nodes.interview": "Neu einlesen",
+  "controller.nodes.interviewed": "Der Knoten wurde neu eingelesen.",
+  "controller.nodes.remove_confirm": "Diesen Knoten entfernen?",
+  "controller.nodes.remove_confirm_body": "{name} verlässt die Fabric dieses Controllers; andere Controller behalten ihn.",
+  "controller.nodes.removed": "Der Knoten ist entfernt.",
+  "controller.nodes.subscribed": "Abonniert",
+  "controller.nodes.window": "Fenster",
+  "controller.overview.addresses": "Adressen",
+  "controller.overview.commissioned_at": "Gekoppelt am",
+  "controller.overview.connection": "Verbindung",
+  "controller.overview.fabric_index": "Unser Fabric-Index auf dem Knoten",
+  "controller.overview.flag.battery_powered": "Batteriebetrieben",
+  "controller.overview.flag.intermittently_connected": "Zeitweise verbunden",
+  "controller.overview.flag.mains_powered": "Netzbetrieben",
+  "controller.overview.flag.supports_ethernet": "Ethernet",
+  "controller.overview.flag.supports_thread": "Thread",
+  "controller.overview.flag.supports_wifi": "WLAN",
+  "controller.overview.flag.thread_sleepy_end_device": "Schlafendes Endgerät",
+  "controller.overview.idle_mode": "Ruhemodus: {seconds} s",
+  "controller.overview.node": "Knoten",
+  "controller.overview.node_id": "Node-ID",
+  "controller.overview.product": "Produkt",
+  "controller.overview.properties": "Eigenschaften",
+  "controller.overview.saved": "Gespeichert.",
+  "controller.overview.serial": "Seriennummer",
+  "controller.overview.software": "Software",
+  "controller.overview.spec_version": "Spezifikationsversion {version}",
+  "controller.overview.subscribe": "Abonnieren",
+  "controller.overview.unsubscribe": "Abonnement beenden",
+  "controller.overview.vendor": "Hersteller",
+  "controller.settings.cap.ble": "Bluetooth LE",
+  "controller.settings.cap.credentials": "Zugangsdaten-Speicher",
+  "controller.settings.cap.ota": "OTA-Provider",
+  "controller.settings.capabilities": "Fähigkeiten",
+  "controller.settings.col_id": "ID",
+  "controller.settings.col_kind": "Art",
+  "controller.settings.col_name": "Name",
+  "controller.settings.compressed_fabric_id": "Komprimierte Fabric-ID",
+  "controller.settings.credential_add": "Speichern",
+  "controller.settings.credential_remove": "Diese Zugangsdaten entfernen?",
+  "controller.settings.credential_saved": "Die Zugangsdaten sind gespeichert.",
+  "controller.settings.credentials": "Netz-Zugangsdaten",
+  "controller.settings.credentials_empty": "Keine Zugangsdaten gespeichert",
+  "controller.settings.dataset": "Operational Dataset (hex)",
+  "controller.settings.fabric_id": "Fabric-ID",
+  "controller.settings.info": "Controller",
+  "controller.settings.label": "Fabric-Bezeichnung",
+  "controller.settings.label_hint": "Bis zu 32 Zeichen; die Knoten erhalten sie im Hintergrund.",
+  "controller.settings.label_saved": "Die Bezeichnung ist gesetzt.",
+  "controller.settings.no_store": "Der Host speichert keine Netz-Zugangsdaten.",
+  "controller.settings.node_id": "Node-ID",
+  "controller.settings.nodes": "Knoten",
+  "controller.settings.passphrase": "Passwort",
+  "controller.settings.ssid": "SSID",
+  "controller.settings.vendor": "Hersteller",
+  "controller.settings.write_only": "Passwort oder Dataset werden nur geschrieben und nie wieder angezeigt.",
+  "controller.subtitle": "Die Knoten, die dieser Controller in Betrieb genommen hat",
+  "controller.tab.commission": "Koppeln",
+  "controller.tab.nodes": "Knoten",
+  "controller.tab.settings": "Einstellungen",
+  "controller.title": "Controller",
+  "controller.updates.check": "Nach Updates suchen",
+  "controller.updates.consent": "Auf {version} aktualisieren",
+  "controller.updates.consented": "Das Update ist eingereiht.",
+  "controller.updates.none_available": "Kein Update verfügbar.",
+  "controller.updates.queue_empty": "Für diesen Knoten ist kein Update eingereiht",
+  "controller.updates.status.in_progress": "Läuft",
+  "controller.updates.status.queued": "Eingereiht",
+  "controller.updates.status.stalled": "Hängt",
+  "controller.updates.unavailable": "Der Controller betreibt keinen OTA-Provider",
+  "controller.updates.version": "Version {version}",
+  "controller.window.close": "Fenster schließen",
+  "controller.window.closed": "Das Fenster ist geschlossen.",
+  "controller.window.discriminator": "Diskriminator",
+  "controller.window.hint": "Ein Fenster öffnen, damit ein weiterer Administrator (ein anderes Ökosystem) diesen Knoten ebenfalls koppeln kann.",
+  "controller.window.manual_code": "Manueller Code",
+  "controller.window.minutes": "{minutes} Minuten",
+  "controller.window.open": "Fenster öffnen",
+  "controller.window.qr_code": "QR-Inhalt",
+  "controller.window.seconds": "{seconds} s",
+  "controller.window.timeout": "Offen für",
   "node.commissioning.closed": "Kopplungsfenster geschlossen",
   "node.diag.age_hours": "{n} h",
   "node.diag.age_minutes": "{n} min",
@@ -156,5 +363,9 @@
   "node.warnings.summary": "{count} Konfigurationswarnungen",
   "node.warnings.title": "Konfigurationswarnungen",
   "select.placeholder": "Auswählen…",
-  "shell.language": "Sprache"
+  "shell.families": "Seitenfamilien",
+  "shell.family.controller": "Controller",
+  "shell.family.node": "Node",
+  "shell.language": "Sprache",
+  "shell.no_family": "Dieser Host stellt weder einen Node noch einen Controller bereit."
 }