@overvis/hmi-workspace-ui 0.0.0-stage → 0.1.0

package/dist/src/workspace/device-presets/settings-write.d.ts

@@ -0,0 +1,73 @@
+import type { ParameterWriteSequenceResult, ParameterWriteValuesInput } from "@overvis/hmi-shared/parameter";
+type ParameterWriteItem = ParameterWriteValuesInput["items"][number];
+/** A confirmed change of a settings section: the setting and the write that applies it. */
+export interface DeviceSettingWrite<Key extends string> {
+    key: Key;
+    item: ParameterWriteItem;
+}
+/**
+ * One step of a section's writes, sent as one request. A step that writes none of the changes,
+ * such as a password unlock or a save to device memory, is shown in the confirmation by its
+ * `label`; its values are never shown.
+ */
+export interface DeviceSettingsWriteStep {
+    items: readonly ParameterWriteItem[];
+    label?: string;
+}
+/**
+ * Turns a section's confirmed changes, in the order of its keys, into ordered steps. A change the
+ * plan leaves out is not written and keeps its draft.
+ */
+export type DeviceSettingsWritePlan<Key extends string> = (changes: readonly DeviceSettingWrite<Key>[]) => readonly DeviceSettingsWriteStep[];
+/** Without a plan, a section writes all its changes together in one request. */
+export declare function defaultDeviceSettingsWritePlan<Key extends string>(changes: readonly DeviceSettingWrite<Key>[]): DeviceSettingsWriteStep[];
+/** The changes a step writes, matched by parameter, in the step's order. */
+export declare function stepChanges<Change extends DeviceSettingWrite<string>>(step: DeviceSettingsWriteStep, changes: readonly Change[]): Change[];
+/** What a section's write sequence did to its changes. */
+export interface DeviceSettingsWriteOutcome<Key extends string> {
+    /** Acknowledged by the device. */
+    written: Key[];
+    /** Reported as failed, or sent without an answer, so they may or may not be on the device. */
+    failed: Key[];
+    /**
+     * The step that stopped the sequence when its failure is not shown on fields: a failed item
+     * that is not a change, or a request that returned no results.
+     */
+    stoppedAt: {
+        step: number;
+        label: string | undefined;
+    } | null;
+}
+/**
+ * Maps a sequence result onto the changes: those in steps before the one that stopped it were
+ * written, those in that step were written or failed by their own result, and later ones were not
+ * sent. A request that returned nothing fails all the changes of its step.
+ */
+export declare function deviceSettingsWriteOutcome<Key extends string>(changes: readonly DeviceSettingWrite<Key>[], steps: readonly DeviceSettingsWriteStep[], result: ParameterWriteSequenceResult): DeviceSettingsWriteOutcome<Key>;
+/** Settings a confirmed write acknowledged, waiting for the next read of each. */
+export interface DeviceSettingsVerifying<Key extends string> {
+    /** The value written to each setting. */
+    values: ReadonlyMap<Key, string>;
+    /** When each setting's value shown at the write was read; null when it had none. */
+    readAt: ReadonlyMap<Key, number | null>;
+    /** Every step was acknowledged, including steps after the changes such as a save. */
+    complete: boolean;
+}
+/** What a confirmed write did once the device was read again. */
+export interface DeviceSettingsVerification<Key extends string> {
+    /** The device now holds what was written. */
+    kept: Key[];
+    /** The device still shows another value, such as a write it acknowledged but ignored. */
+    notKept: Key[];
+    /**
+     * Every step of the write was acknowledged. False when a later step, such as a save to device
+     * memory, failed after the changes were written, so a restart would lose them.
+     */
+    complete: boolean;
+}
+/**
+ * Compares acknowledged writes with the first read of each setting after them; null until every
+ * written setting has a newer read. `current` holds the device values as drafts.
+ */
+export declare function deviceSettingsVerification<Key extends string>(verifying: DeviceSettingsVerifying<Key>, receivedAt: ReadonlyMap<Key, number | null>, current: Readonly<Record<string, string>>): DeviceSettingsVerification<Key> | null;
+export {};

package/dist/src/workspace/device-presets/state-text.d.ts

@@ -0,0 +1,17 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import type { ReactElement } from "react";
+import { type ParameterValueState } from "../parameters/live/model.js";
+/**
+ * A boolean reading as muted text. With `fault`, a true value is a fault and turns
+ * destructive. With `flag`, a numeric zero or nonzero value counts as false or true too.
+ * Loading, stale and unavailable states follow `ParameterValueDisplay`.
+ */
+export declare function ParameterStateText({ state, trueLabel, falseLabel, locale, fault, flag, className, }: {
+    state: ParameterValueState;
+    trueLabel: string;
+    falseLabel: string;
+    locale: AppLocale;
+    fault?: boolean;
+    flag?: boolean;
+    className?: string;
+}): ReactElement;

package/dist/src/workspace/device-presets/trend-chart.d.ts

@@ -0,0 +1,51 @@
+import { type ReactElement } from "react";
+import type { ParameterHistoryPoint } from "../parameters/live/use-history.js";
+export interface ParameterTrendSeries {
+    label: string;
+    points: readonly ParameterHistoryPoint[];
+    /**
+     * The series color, by its place among the trend colors; its position in `series` by default. A
+     * chart that hides some series passes it so each keeps its color, such as L3 its violet.
+     */
+    colorIndex?: number;
+}
+/** One to four series; each has its own color. */
+export type ParameterTrendSeriesList = readonly [ParameterTrendSeries] | readonly [ParameterTrendSeries, ParameterTrendSeries] | readonly [ParameterTrendSeries, ParameterTrendSeries, ParameterTrendSeries] | readonly [
+    ParameterTrendSeries,
+    ParameterTrendSeries,
+    ParameterTrendSeries,
+    ParameterTrendSeries
+];
+/** The first four of `series` for a chart; null when there are none, so no chart is drawn. */
+export declare function parameterTrendSeriesList(series: readonly ParameterTrendSeries[]): ParameterTrendSeriesList | null;
+/**
+ * Line chart of the last `windowMs` of one to four readings in one unit, with an optional
+ * reference line such as a setpoint. The row above shows the latest values; hovering shows a
+ * tooltip with the nearest sample of each series. The plot is a slider for keyboard and screen
+ * reader users: arrow keys, Home and End step through samples, and each step announces the
+ * sample's time and values. Values come from `useParameterValueHistory`.
+ * With `followClock`, the window keeps moving while no new samples arrive, so a stalled
+ * reading shows as a trailing gap; otherwise it ends at the latest sample.
+ * `emphasis` is the index of the series to draw bolder than the others, which are dimmed.
+ */
+export declare function ParameterTrendChart({ series, unit, label, reference, emphasis, followClock, windowMs, gapThresholdMs, fractionDigits, summary, className, }: {
+    series: ParameterTrendSeriesList;
+    unit: string;
+    /** Accessible name of the chart. */
+    label: string;
+    reference?: {
+        value: number;
+        label: string;
+    } | null;
+    emphasis?: number | null;
+    followClock: boolean;
+    windowMs?: number;
+    gapThresholdMs?: number;
+    fractionDigits?: number;
+    /**
+     * The latest values and the reference above the chart. Leave it off where the page already
+     * shows them beside the chart; hovering still shows each sample.
+     */
+    summary?: boolean;
+    className?: string;
+}): ReactElement;

package/dist/src/workspace/device-presets/trend-model.d.ts

@@ -0,0 +1,45 @@
+import type { ParameterHistoryPoint } from "../parameters/live/use-history.js";
+export interface ParameterTrendScale {
+    lower: number;
+    upper: number;
+    from: number;
+    to: number;
+    /** Each series' points inside the window, in input order. */
+    series: ParameterHistoryPoint[][];
+}
+/**
+ * Fit the window ending at `to` and a rounded value range around the visible points and the
+ * reference value. The range never collapses, so a constant reading stays inside the chart.
+ */
+export declare function parameterTrendScale(input: {
+    series: readonly (readonly ParameterHistoryPoint[])[];
+    reference: number | null;
+    to: number;
+    windowMs: number;
+}): ParameterTrendScale;
+export declare function nearestTrendPoint(points: readonly ParameterHistoryPoint[], at: number): ParameterHistoryPoint | undefined;
+export interface ParameterTrendSelection {
+    at: number;
+    /** The selected point of each series; `undefined` for a series with no visible points. */
+    points: (ParameterHistoryPoint | undefined)[];
+}
+/**
+ * Without a pointer, select each series' latest point. With one, snap to the sample nearest
+ * to the pointer across all series, then take each series' sample nearest to that time.
+ */
+export declare function selectTrendPoints(series: readonly (readonly ParameterHistoryPoint[])[], hoveredAt: number | null): ParameterTrendSelection | null;
+/** SVG path data; a gap longer than `gapThresholdMs` starts a new segment. */
+export declare function trendPath(points: readonly ParameterHistoryPoint[], x: (at: number) => number, y: (value: number) => number, gapThresholdMs: number): string;
+/** Sample times across all series, ascending and without duplicates. */
+export declare function trendSampleTimes(series: readonly (readonly ParameterHistoryPoint[])[]): number[];
+export type TrendStep = "previous" | "next" | "first" | "last";
+/**
+ * Keyboard selection over sample times. Without a current selection, every step except
+ * `first` starts from the latest sample.
+ */
+export declare function stepTrendTime(times: readonly number[], current: number | null, step: TrendStep): number | null;
+/**
+ * The decimals that keep the axis tick labels apart: `fractionDigits`, or more when a narrow
+ * range would round neighbouring ticks to the same label.
+ */
+export declare function trendTickDigits(ticks: readonly number[], fractionDigits: number): number;

package/dist/src/workspace/device-presets/unsupported.d.ts

@@ -0,0 +1,14 @@
+import { type ParameterDiagnostic, type ParameterValueState } from "../parameters/live/model.js";
+/** The device rejected the request because it has no such register. */
+export declare function isUnsupportedParameterDiagnostic(diagnostic: ParameterDiagnostic): boolean;
+/**
+ * The device rejected the latest read because it has no such register, as some firmware versions
+ * do for registers their manual lists, whether or not an earlier value is kept. Such a reading is
+ * shown as not supported rather than as an error.
+ */
+export declare function isUnsupportedParameterValue(state: ParameterValueState | undefined): boolean;
+/**
+ * Leave out the failed reads of only `optionalIds` registers that the device does not have. A
+ * diagnostic collapsed over several reads keeps the reads of other parameters.
+ */
+export declare function withoutOptionalUnsupported(diagnostics: readonly ParameterDiagnostic[], optionalIds: readonly string[]): ParameterDiagnostic[];

package/dist/src/workspace/device-presets/values.d.ts

@@ -0,0 +1,56 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import { type ParameterDiagnostic, type ParameterValueState, type ParameterValuesDemand } from "../parameters/live/model.js";
+export interface DevicePresetDiagnostics {
+    /** The device's connection is down; shown as one banner instead of per-reading alerts. */
+    endpointDiagnostic: ParameterDiagnostic | null;
+    otherDiagnostics: readonly ParameterDiagnostic[];
+}
+/**
+ * Split one device's diagnostics into the connection failure and everything else. The first
+ * endpoint diagnostic becomes the banner, and later endpoint diagnostics that name the same
+ * endpoint add their readings to it. Endpoint diagnostics for any other endpoint stay in
+ * `otherDiagnostics`, so a reading bound to the wrong endpoint is still reported.
+ */
+export declare function splitEndpointDiagnostic(diagnostics: readonly ParameterDiagnostic[]): DevicePresetDiagnostics;
+export interface DevicePresetValues extends DevicePresetDiagnostics {
+    summary: ParameterValuesDemand;
+    retry: () => void;
+}
+/**
+ * Poll one device's readings in two cohorts: `fastIds` for live readings and `slowIds` for
+ * settings and identity values that rarely change. Pausing stops both.
+ */
+export declare function useDevicePresetValues({ fastIds, slowIds, live, fastIntervalMs, slowIntervalMs, }: {
+    fastIds: readonly string[];
+    slowIds: readonly string[];
+    live: boolean;
+    fastIntervalMs?: number;
+    slowIntervalMs?: number;
+}): DevicePresetValues;
+/**
+ * A parameter's engineering unit in `locale`, so a dashboard shows the unit its bound parameter
+ * is scaled to. Empty while loading, for a parameter without a unit, and for an empty id.
+ */
+export declare function useParameterUnit(parameterId: string, locale: AppLocale): string;
+export interface DeviceReadings {
+    /** Every reading in `parameterIds` order, or null until all of them are known. */
+    values: number[] | null;
+    /** When the oldest reading kept from an earlier read was received; null when all are fresh. */
+    staleSince: number | null;
+}
+/**
+ * Numbers that are read together, such as the three line voltages. A partial set would look
+ * complete, so there are values only when every reading is known. While the readings do not come
+ * from one read — a read has updated only some of them so far, or failed for some — the last
+ * complete set stays, marked with when the oldest reading was kept from an earlier read. This
+ * observes the readings; the dashboard's polling reads them.
+ */
+export declare function useDeviceReadings(parameterIds: readonly string[]): DeviceReadings;
+/**
+ * The readings of `states`, and whether they mix two reads: a read has updated only some of them
+ * so far, or some are from the latest read and others kept from an earlier one.
+ */
+export declare function deviceReadingsOf(states: readonly ParameterValueState[]): {
+    readings: DeviceReadings;
+    mixed: boolean;
+};

package/dist/src/workspace/edge-programs/deploy-status.d.ts

@@ -0,0 +1,12 @@
+import { type EdgeDeployStatus } from "@overvis/hmi-shared/endpoint";
+export interface EdgeDeployStatusFeed {
+    /** The latest status; null until the first one arrives. */
+    readonly status: EdgeDeployStatus | null;
+    /** False while the subscription is (re)connecting or failed: `status` may be out of date. */
+    readonly live: boolean;
+}
+/**
+ * Where an MC252's programs stand, kept current while a deploy runs. Pass null for an endpoint
+ * that runs no programs.
+ */
+export declare function useEdgeDeployStatus(endpointId: string | null): EdgeDeployStatusFeed;

package/dist/src/workspace/edge-programs/diagnostic-text.d.ts

@@ -0,0 +1,9 @@
+import type { TaskfileDiagnostic } from "@overvis/hmi-shared/taskfile";
+/** A taskfile validator diagnostic in the UI language. */
+export declare function taskfileDiagnosticText(diagnostic: TaskfileDiagnostic): string;
+/** A compile error the device reported (for example `ERROR_ITEM_REF`), in the UI language. */
+export declare function edgeDeviceErrorText(code: string): string;
+/** A task's last run-time error as the device reports it (for example `EXC_MB_SLAVE_BUSY`). */
+export declare function edgeTaskErrorText(code: string): string;
+/** Why the last deploy failed when the device reported no compile error. */
+export declare function edgeDeployErrorText(code: string): string;

package/dist/src/workspace/edge-programs/editor-language.d.ts

@@ -0,0 +1,15 @@
+import { type TaskfileDiagnostic, type TaskfileFix, type TaskfileLanguageService, type TaskfileLocation } from "@overvis/hmi-shared/taskfile";
+import type { CodeEditorAction } from "../../code-editor/code-editor.js";
+import type { EditorLanguage } from "../../code-editor/language-features.js";
+/** Opens a place in another program of the device; null where programs cannot be switched. */
+export type OpenProgramLocation = ((location: TaskfileLocation) => void) | null;
+/** The editor features of the MC252 program `filename` among the device's programs. */
+export declare function edgeProgramEditorLanguage(service: TaskfileLanguageService, filename: string, openLocation: OpenProgramLocation, labels: {
+    readonly docs: string;
+    readonly references: string;
+    readonly rename: string;
+}): EditorLanguage;
+/** A fix as a problem's action, in the UI language. */
+export declare function edgeProgramFixAction(fix: TaskfileFix): CodeEditorAction;
+/** Fixes of a problem, as actions. */
+export declare function edgeProgramFixActions(service: TaskfileLanguageService, text: string, diagnostic: TaskfileDiagnostic): CodeEditorAction[];

package/dist/src/workspace/edge-programs/item-descriptions.d.ts

@@ -0,0 +1,3 @@
+import type { TaskfileLanguageItemId } from "@overvis/hmi-shared/taskfile";
+/** One line about an MC252 program language item, in the UI language. */
+export declare function edgeProgramItemDescription(id: TaskfileLanguageItemId): string;

package/dist/src/workspace/edge-programs/live-state.d.ts

@@ -0,0 +1,12 @@
+import { type EdgeLiveState } from "@overvis/hmi-shared/endpoint";
+export interface EdgeLiveStateFeed {
+    /** The latest read; null until the first one arrives, and while the subscription reconnects. */
+    readonly state: EdgeLiveState | null;
+    /** The subscription failed and is not retrying. */
+    readonly failed: boolean;
+}
+/**
+ * A program's live state on its MC252, read while this hook is mounted and the page is visible.
+ * Unmounting or hiding the page ends the subscription, so the device is no longer read.
+ */
+export declare function useEdgeLiveState(programId: string): EdgeLiveStateFeed;

package/dist/src/workspace/endpoint-status/provider.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from "react";
+import { type KnownEndpointStatus } from "./store.js";
+/** State of the workspace's status subscription, as tRPC reports it. */
+export type EndpointStatusFeed = "idle" | "connecting" | "pending" | "error";
+/**
+ * Holds one `endpoint.watchStatus` subscription for the workspace and serves every status reader
+ * below it. The subscription is open only while at least one reader is mounted.
+ */
+export declare function EndpointStatusProvider({ workspaceId, children, }: {
+    workspaceId: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Live status of one endpoint of the current workspace. */
+export declare function useEndpointStatus(endpointId: string): KnownEndpointStatus;
+/** State of the workspace's status subscription. */
+export declare function useEndpointStatusFeed(): EndpointStatusFeed;

package/dist/src/workspace/endpoint-status/store.d.ts

@@ -0,0 +1,18 @@
+import type { EndpointStatus, EndpointStatusEvent } from "@overvis/hmi-shared/endpoint";
+/**
+ * One endpoint's live status as the page knows it: `undefined` before the first snapshot, `null`
+ * when the connector has not reported on the endpoint.
+ */
+export type KnownEndpointStatus = EndpointStatus | null | undefined;
+/** Endpoint statuses of one workspace, fed by `endpoint.watchStatus` events. */
+export declare class EndpointStatusStore {
+    private statuses;
+    private loaded;
+    private readonly listeners;
+    readonly subscribe: (listener: () => void) => (() => void);
+    get(endpointId: string): KnownEndpointStatus;
+    apply(event: EndpointStatusEvent): void;
+    /** Forgets everything until the next snapshot. */
+    clear(): void;
+    private notify;
+}

package/dist/src/workspace/errors.d.ts

@@ -0,0 +1 @@
+export declare function isWorkspaceNoAccessError(error: unknown): boolean;

package/dist/src/workspace/fleet/alarms.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from "react";
+import type { DashboardLocation, SiteAlarmSeverity } from "@overvis/hmi-shared/dashboard";
+import { type DashboardNavigation } from "../dashboards/navigation.js";
+/** One active alarm on the fleet overview. */
+export interface FleetAlarm {
+    /** Unique within the list. */
+    key: string;
+    severity: SiteAlarmSeverity;
+    siteName: string;
+    /** Site page, optionally anchored to the equipment that raised the alarm. */
+    to: DashboardLocation;
+    description: ReactNode;
+}
+/**
+ * Known active alarms across the filtered sites, critical first, in a panel that keeps its place
+ * and height: room for three one-line alarms, scrolling beyond them, so the page below never
+ * moves as alarms come and go. **No active alarms** needs every alarm state to be known: while
+ * some are `unknown`, such as an offline site's, the panel says so instead, and while the first
+ * values are `pending` it stays empty.
+ */
+export declare function FleetAlarmList({ alarms, navigation, pending, unknown, }: {
+    alarms: readonly FleetAlarm[];
+    navigation: Pick<DashboardNavigation, "href" | "navigate">;
+    pending?: boolean;
+    /** Some alarm states of the listed sites cannot be evaluated, so none active is no all-clear. */
+    unknown?: boolean;
+}): import("react").JSX.Element;

package/dist/src/workspace/fleet/binding-editor.d.ts

@@ -0,0 +1,65 @@
+import { type ReactNode } from "react";
+import { type SiteAlarm, type SiteReading } from "@overvis/hmi-shared/dashboard";
+import { type ParameterControl } from "@overvis/hmi-shared/parameter";
+import { type FormValidationErrorResult } from "../../form/index.js";
+export type SiteBindingKind = "readings" | "alarms" | "controls";
+/** What a binding editor saves: a reading, an alarm or a control. */
+export type SiteBinding<Category extends string> = {
+    kind: "readings";
+    item: SiteReading & {
+        role: Category;
+    };
+} | {
+    kind: "alarms";
+    item: SiteAlarm;
+} | {
+    kind: "controls";
+    item: ParameterControl;
+};
+declare const controlCategories: readonly ["start", "stop", "mode", "reset", "other"];
+type ControlCategory = (typeof controlCategories)[number];
+/**
+ * Adds or edits one reading, alarm or control of a site or its equipment. Readings get a unit
+ * from parameter metadata; write controls must bind writable parameters. `onSave` receives the
+ * validated item and applies it to the configuration; throw a `FleetConfigurationError` to show
+ * a conflict. With `command`, it edits a named command slot: no setpoint choice and a fixed
+ * purpose.
+ */
+export declare function SiteBindingEditor<Category extends string>({ kind, item, categories, summary, command, title, workspaceId, onSave, onClose, mapError, }: {
+    kind: SiteBindingKind;
+    item: (SiteReading & {
+        role: Category;
+    }) | SiteAlarm | ParameterControl | null;
+    /** Reading categories with labels; the first is the default for a new reading. */
+    categories: readonly {
+        value: Category;
+        label: string;
+    }[];
+    /** Offers the "show on the overview" option for readings. */
+    summary?: boolean;
+    /**
+     * Command-only mode for `kind: "controls"`: a command with this fixed purpose; `name` fills
+     * the name of a new command.
+     */
+    command?: {
+        category: ControlCategory;
+        name?: string;
+    };
+    /** Dialog title, such as a slot's name; defaults to the kind's title. */
+    title?: string;
+    workspaceId: string;
+    onSave: (binding: SiteBinding<Category>) => Promise<void>;
+    onClose: () => void;
+    mapError?: (error: unknown) => FormValidationErrorResult;
+}): import("react").JSX.Element;
+/** Confirms deleting a named item; `onDelete` applies the removal. */
+export declare function FleetDeleteDialog({ name, details, onDelete, onClose, onDeleted, mapError, }: {
+    name: string;
+    /** What else the deletion changes, such as items that move elsewhere. */
+    details?: ReactNode;
+    onDelete: () => Promise<void>;
+    onClose: () => void;
+    onDeleted?: () => void;
+    mapError?: (error: unknown) => FormValidationErrorResult;
+}): import("react").JSX.Element;
+export {};

package/dist/src/workspace/fleet/board-editor.d.ts

@@ -0,0 +1,118 @@
+import Type, { type Static } from "typebox";
+import { type FleetZone } from "@overvis/hmi-shared/dashboard";
+import { type FormValidationErrorResult } from "../../form/index.js";
+/** Board display and zones as `BoardSettingsFields` edits them. */
+export declare const boardSettingsFormType: Type.TObject<{
+    board: Type.TObject<{
+        representation: Type.TUnion<[Type.TLiteral<"cards">, Type.TLiteral<"table">]>;
+        groupByZone: Type.TBoolean;
+        columns: Type.TArray<Type.TString>;
+    }>;
+    zones: Type.TRecord<"^.*$", Type.TObject<{
+        id: Type.TString;
+        name: Type.TString;
+    }>>;
+}>;
+export type BoardSettingsFormValue = Static<typeof boardSettingsFormType>;
+interface BoardSettings<Category extends string> {
+    board: {
+        representation: "cards" | "table";
+        groupByZone: boolean;
+        columns: Category[];
+    };
+    zones: FleetZone[];
+}
+/** Form values of a board's display settings and zones. */
+export declare function boardSettingsFormValue(board: {
+    representation: "cards" | "table";
+    groupByZone: boolean;
+    columns: readonly string[];
+}, zones: readonly FleetZone[]): BoardSettingsFormValue;
+/** The board settings a form describes; columns keep only the offered categories. */
+export declare function boardSettingsFromForm<Category extends string>(value: BoardSettingsFormValue, categories: readonly {
+    value: Category;
+}[]): BoardSettings<Category>;
+/**
+ * Cards or table, zone grouping, summary columns (reading categories) and the zone list. Place
+ * it with `fields` at a `boardSettingsFormValue` and read it back with `boardSettingsFromForm`.
+ */
+export declare const BoardSettingsFields: <TFormData, TFields extends import("@tanstack/react-form").DeepKeysOfType<TFormData, {
+    board: {
+        representation: "cards" | "table";
+        groupByZone: boolean;
+        columns: string[];
+    };
+    zones: Record<string, {
+        id: string;
+        name: string;
+    }>;
+} | null | undefined> | import("@tanstack/react-form").FieldsMap<TFormData, {
+    board: {
+        representation: "cards" | "table";
+        groupByZone: boolean;
+        columns: string[];
+    };
+    zones: Record<string, {
+        id: string;
+        name: string;
+    }>;
+}>, TOnMount extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnChange extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TFormSubmitMeta>(params: import("react").PropsWithChildren<NoInfer<{
+    /** Reading categories offered as summary columns, in display order. */
+    categories: readonly {
+        value: string;
+        label: string;
+    }[];
+    /** Label of the cards/table choice, such as "Station display". */
+    representationLabel?: string;
+}> & {
+    form: import("@tanstack/react-form").AppFieldExtendedReactFieldGroupApi<unknown, TFormData, string | import("@tanstack/react-form").FieldsMap<unknown, TFormData>, any, any, any, any, any, any, any, any, any, any, TFormSubmitMeta, {
+        readonly TextField: typeof import("../../index.js").TextField;
+        readonly TextAreaField: typeof import("../../index.js").TextAreaField;
+        readonly OtpField: typeof import("../../index.js").OtpField;
+        readonly CheckboxField: typeof import("../../index.js").CheckboxField;
+        readonly ParameterPickerField: typeof import("../../index.js").ParameterPickerField;
+        readonly DashboardPickerField: typeof import("../../index.js").DashboardPickerField;
+        readonly FormulaField: typeof import("../../index.js").FormulaField;
+    }, {
+        readonly FormRoot: typeof import("../../index.js").FormRoot;
+        readonly FormErrorBanner: typeof import("../../index.js").FormErrorBanner;
+        readonly SubmitButton: typeof import("../../index.js").SubmitButton;
+    }> | import("@tanstack/react-form").AppFieldExtendedReactFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TFormSubmitMeta, {
+        readonly TextField: typeof import("../../index.js").TextField;
+        readonly TextAreaField: typeof import("../../index.js").TextAreaField;
+        readonly OtpField: typeof import("../../index.js").OtpField;
+        readonly CheckboxField: typeof import("../../index.js").CheckboxField;
+        readonly ParameterPickerField: typeof import("../../index.js").ParameterPickerField;
+        readonly DashboardPickerField: typeof import("../../index.js").DashboardPickerField;
+        readonly FormulaField: typeof import("../../index.js").FormulaField;
+    }, {
+        readonly FormRoot: typeof import("../../index.js").FormRoot;
+        readonly FormErrorBanner: typeof import("../../index.js").FormErrorBanner;
+        readonly SubmitButton: typeof import("../../index.js").SubmitButton;
+    }>;
+    fields: TFields;
+}>) => ReturnType<import("react").FunctionComponent>;
+/**
+ * Board settings: cards or table, zone grouping, summary columns (reading categories) and the
+ * zone list. Removing a zone unassigns its sites when `onSave` uses `saveFleetBoard`. A board
+ * with more settings composes `BoardSettingsFields` in its own dialog instead.
+ */
+export declare function BoardEditor<Category extends string>({ board, zones, categories, representationLabel, onSave, onClose, mapError, }: {
+    board: {
+        representation: "cards" | "table";
+        groupByZone: boolean;
+        columns: readonly Category[];
+    };
+    zones: readonly FleetZone[];
+    /** Reading categories offered as summary columns, in display order. */
+    categories: readonly {
+        value: Category;
+        label: string;
+    }[];
+    /** Label of the cards/table choice, such as "Station display". */
+    representationLabel?: string;
+    onSave: (value: BoardSettings<Category>) => Promise<void>;
+    onClose: () => void;
+    mapError?: (error: unknown) => FormValidationErrorResult;
+}): import("react").JSX.Element;
+export {};

package/dist/src/workspace/fleet/command-buttons.d.ts

@@ -0,0 +1,19 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import type { SiteCommandEntry } from "./command-entry.js";
+import type { SiteControlMode, SiteLocalControl } from "./control-mode.js";
+/**
+ * Command buttons of a site or one piece of its equipment, grouped by purpose. Each opens the
+ * write sequence, so commands of several steps work. Disabled while the local selector is on; in
+ * automatic or unknown mode a switching command warns that the controller may switch it back. A
+ * dialog whose command changed in setup while it was open cannot run. Unbound commands are not
+ * shown, and without `canWrite` (see `canWriteParameterValues`) nothing is. `notes` explains local
+ * control under the buttons; leave it off where the site's own buttons already do.
+ */
+export declare function SiteCommandButtons({ commands, local, mode, locale, canWrite, notes, }: {
+    commands: readonly SiteCommandEntry[];
+    local: SiteLocalControl;
+    mode: SiteControlMode | null;
+    locale: AppLocale;
+    canWrite: boolean;
+    notes?: boolean;
+}): import("react").JSX.Element | null;

package/dist/src/workspace/fleet/command-entry.d.ts

@@ -0,0 +1,25 @@
+import type { ParameterControl } from "@overvis/hmi-shared/parameter";
+/** A site command control. */
+export type SiteCommand = Extract<ParameterControl, {
+    kind: "command";
+}>;
+/** One button of `SiteCommandButtons`. */
+export interface SiteCommandEntry {
+    key: string;
+    label: string;
+    /**
+     * `on` and `off` switch equipment and warn while a controller may switch it back;
+     * `automatic`, `manual` and `mode` change who is in control; `reset` and `other` do neither.
+     * Buttons are grouped by purpose in that order.
+     */
+    kind: "on" | "off" | "automatic" | "manual" | "mode" | "reset" | "other";
+    /** The bound command; an unbound or setpoint control shows no button. */
+    control: ParameterControl | undefined;
+    /** Shown as pressed, such as the mode the feedback reports; null while unknown. */
+    pressed?: boolean | null;
+}
+/**
+ * A configured command control as a button: start and stop switch, a mode command changes who
+ * is in control. `pressed` applies when the command has an active condition.
+ */
+export declare function siteCommandEntry(control: SiteCommand, pressed: boolean | null): SiteCommandEntry;