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

package/dist/src/workspace/dashboards/use-configuration-mutation.d.ts

@@ -0,0 +1,40 @@
+import type { Static, TSchema } from "typebox";
+export interface UseDashboardConfigurationMutationOptions<T extends TSchema> {
+    dashboardId: string;
+    workspaceId: string;
+    schema: T;
+}
+/** Read the current dashboard, transform its validated configuration, and preserve its metadata. */
+export declare function useDashboardConfigurationMutation<T extends TSchema>({ dashboardId, workspaceId, schema, }: UseDashboardConfigurationMutationOptions<T>): {
+    update: (transform: (configuration: Static<T>) => Static<T>) => Promise<void>;
+    isPending: boolean;
+    error: import("@trpc/client").TRPCClientErrorLike<{
+        input: {
+            id: string;
+            name: string | Record<string, string>;
+            description: string | Record<string, string> | null;
+            icon: string | null;
+            configuration: Record<string, unknown>;
+            expectedConfiguration?: Record<string, unknown>;
+            baseRevision?: number;
+        };
+        output: {
+            id: string;
+            workspaceId: string;
+            name: string | Record<string, string>;
+            description: string | Record<string, string> | null;
+            icon: string | null;
+            configuration: Record<string, unknown>;
+            disabledSince: string | null;
+            revision: number;
+            createdAt: string;
+            updatedAt: string;
+        };
+        transformer: false;
+        errorShape: {
+            code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+            message: string;
+            data: Record<string, unknown>;
+        };
+    }> | null;
+};

package/dist/src/workspace/device-api/errors.d.ts

@@ -0,0 +1,6 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+/**
+ * Localized text for a failed device API call: the role a refused call needs, when a rate-limited
+ * call may be repeated, and the status a device error answered with; otherwise the API error text.
+ */
+export declare function deviceApiErrorText(error: unknown, locale?: AppLocale): string;

package/dist/src/workspace/device-api/use-device-api.d.ts

@@ -0,0 +1,75 @@
+import { type DeviceApiCallInput, type DeviceApiOperationSummary } from "@overvis/hmi-shared/device-api";
+/**
+ * Shortest time between automatic reads of one operation. Every read reaches the device, counts
+ * as API usage and shares the operation's rate limit with every other viewer.
+ */
+export declare const DEVICE_API_MIN_REFRESH_MS = 15000;
+export interface DeviceApi {
+    /**
+     * `unsupported`: the endpoint is not an enabled PIN endpoint of a device with built-in
+     * operations. `ready` with no operations: the viewer's role allows none.
+     */
+    readonly status: "loading" | "unsupported" | "error" | "ready";
+    readonly error: unknown;
+    /** The device's manifest, such as `overvis/mc252`, and model, such as `mc252`. */
+    readonly manifestId: string | null;
+    readonly model: string | null;
+    /** The operations the viewer's role allows from dashboards. */
+    readonly operations: readonly DeviceApiOperationSummary[];
+    operation(id: string): DeviceApiOperationSummary | null;
+    /** Whether the viewer may call the operation with this input, per-key roles included. */
+    canCall(id: string, input?: DeviceApiCallInput): boolean;
+}
+/** The device operations of a PIN endpoint that the viewer may call, from `device.api.list`. */
+export declare function useDeviceApi(endpointId: string | null | undefined): DeviceApi;
+/** How long a rate-limited call asks to wait before the next one; null for other outcomes. */
+export declare function rateLimitWaitMs(error: unknown): number | null;
+export interface DeviceApiRead<T> {
+    /**
+     * `unavailable`: the endpoint has no such read operation, or the viewer's role cannot call
+     * it with this input. `error` keeps the last good `data`.
+     */
+    readonly status: "loading" | "unavailable" | "error" | "ready";
+    readonly data: T | undefined;
+    readonly error: unknown;
+    readonly isFetching: boolean;
+    /** When the shown `data` was read; null before the first answer. */
+    readonly updatedAt: Date | null;
+    refresh(): void;
+}
+export interface DeviceApiReadOptions {
+    endpointId: string | null | undefined;
+    operation: string;
+    input?: DeviceApiCallInput;
+    /** Re-read this often while the page is visible; at least 15 s. Without it, read once. */
+    refreshMs?: number;
+    enabled?: boolean;
+}
+/**
+ * Reads a device operation whose effect is `read` as the viewer. Components that read the same
+ * operation with the same input share one call. `select` shapes the device's JSON answer;
+ * without it `data` is that answer as `unknown`.
+ */
+export declare function useDeviceApiRead<T>(options: DeviceApiReadOptions & {
+    select: (response: unknown) => T;
+}): DeviceApiRead<T>;
+export declare function useDeviceApiRead(options: DeviceApiReadOptions): DeviceApiRead<unknown>;
+export interface DeviceApiAction {
+    /** Whether the device has the operation and the viewer's role allows it. */
+    readonly available: boolean;
+    /** Whether the viewer may call it with this input, per-key roles included. */
+    canCall(input?: DeviceApiCallInput): boolean;
+    /**
+     * Calls the operation and resolves with the device's JSON answer; rejects with the API error.
+     * Reads of the same endpoint are read again after a successful call.
+     */
+    call(input?: DeviceApiCallInput): Promise<unknown>;
+    readonly isPending: boolean;
+    readonly error: unknown;
+    reset(): void;
+}
+/** Calls a device operation, typically a `write` such as a command, as the viewer. */
+export declare function useDeviceApiAction(options: {
+    endpointId: string | null | undefined;
+    operation: string;
+}): DeviceApiAction;

package/dist/src/workspace/device-presets/cold-room-card.d.ts

@@ -0,0 +1,17 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+import { type ReactElement, type ReactNode } from "react";
+import { type ColdRoomBindings } from "./cold-room-model.js";
+/**
+ * One refrigerated room: temperature against its setpoint and alarm limits, equipment states,
+ * active alarms, and defrost and on/off commands. The host polls the parameters listed by
+ * `coldRoomParameterIds`; the card only reads them. A missing binding hides its part. Commands
+ * run through a confirmed write sequence and need write access and a current room temperature.
+ */
+export declare function ColdRoomCard({ name, bindings, locale, temperatureUnit, className, }: {
+    name: ReactNode;
+    bindings: ColdRoomBindings;
+    locale: AppLocale;
+    /** Replaces the temperature parameters' unit, such as °F while the controller displays it. */
+    temperatureUnit?: string;
+    className?: string;
+}): ReactElement;

package/dist/src/workspace/device-presets/cold-room-commands.d.ts

@@ -0,0 +1,19 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import type { ComponentProps } from "react";
+import type { Button } from "../../ui/button.js";
+import { type ColdRoomBindings } from "./cold-room-model.js";
+import type { ParameterValueState } from "../parameters/live/model.js";
+/**
+ * A cold-room controller's commands: **Start defrost**, **Switch on** while it is in stand-by and
+ * **Stand-by** while it runs, each confirmed before its writes are sent, with a note when they
+ * need a current room reading or write access. Every bound command stays mounted and is only
+ * hidden while not offered, so a confirmation open while the state changes still reports its
+ * result. Renders nothing when no command is bound.
+ */
+export declare function ColdRoomCommands({ bindings, states, locale, size, onAcknowledged, }: {
+    bindings: ColdRoomBindings;
+    states: ReadonlyMap<string, ParameterValueState>;
+    locale: AppLocale;
+    size?: ComponentProps<typeof Button>["size"];
+    onAcknowledged?: () => void;
+}): import("react").JSX.Element | null;

package/dist/src/workspace/device-presets/cold-room-labels.d.ts

@@ -0,0 +1,5 @@
+import type { ColdRoomCommand, ColdRoomStatus } from "./cold-room-model.js";
+/** What a cold-room controller is doing, as `ColdRoomCard` and presets show it. */
+export declare function coldRoomStatusLabel(status: ColdRoomStatus): string;
+/** A cold-room controller command's button label. */
+export declare function coldRoomCommandLabel(command: ColdRoomCommand): string;

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

@@ -0,0 +1,141 @@
+import { type ParameterWriteValuesInput } from "@overvis/hmi-shared/parameter";
+import Type, { type Static } from "typebox";
+import { type ParameterValueState } from "../parameters/live/model.js";
+declare const commandsType: Type.TObject<{
+    defrost: Type.TOptional<Type.TArray<Type.TObject<{
+        id: Type.TString;
+        parameterId: Type.TString;
+        value: Type.TString;
+    }>>>;
+    on: Type.TOptional<Type.TArray<Type.TObject<{
+        id: Type.TString;
+        parameterId: Type.TString;
+        value: Type.TString;
+    }>>>;
+    off: Type.TOptional<Type.TArray<Type.TObject<{
+        id: Type.TString;
+        parameterId: Type.TString;
+        value: Type.TString;
+    }>>>;
+}>;
+/**
+ * Parameters of one refrigerated room on any controller. Only the room temperature and the
+ * setpoint are required; an absent binding hides its reading, state, limit or command.
+ */
+export declare const coldRoomBindingsType: Type.TObject<{
+    temperature: Type.TString;
+    setpoint: Type.TString;
+    evaporatorTemperature: Type.TOptional<Type.TString>;
+    auxiliaryTemperature: Type.TOptional<Type.TString>;
+    compressor: Type.TOptional<Type.TString>;
+    defrost: Type.TOptional<Type.TString>;
+    fans: Type.TOptional<Type.TString>;
+    door: Type.TOptional<Type.TString>;
+    standby: Type.TOptional<Type.TString>;
+    heating: Type.TOptional<Type.TString>;
+    alarms: Type.TOptional<Type.TArray<Type.TString>>;
+    setpointMinimum: Type.TOptional<Type.TString>;
+    setpointMaximum: Type.TOptional<Type.TString>;
+    differential: Type.TOptional<Type.TString>;
+    highAlarm: Type.TOptional<Type.TString>;
+    lowAlarm: Type.TOptional<Type.TString>;
+    alarmThresholdsRelative: Type.TOptional<Type.TString>;
+    commands: Type.TOptional<Type.TObject<{
+        defrost: Type.TOptional<Type.TArray<Type.TObject<{
+            id: Type.TString;
+            parameterId: Type.TString;
+            value: Type.TString;
+        }>>>;
+        on: Type.TOptional<Type.TArray<Type.TObject<{
+            id: Type.TString;
+            parameterId: Type.TString;
+            value: Type.TString;
+        }>>>;
+        off: Type.TOptional<Type.TArray<Type.TObject<{
+            id: Type.TString;
+            parameterId: Type.TString;
+            value: Type.TString;
+        }>>>;
+    }>>;
+}>;
+export type ColdRoomBindings = Static<typeof coldRoomBindingsType>;
+export type ColdRoomCommand = keyof Static<typeof commandsType>;
+export type ColdRoomStatus = "standby" | "defrost" | "cooling" | "heating" | "idle";
+type States = ReadonlyMap<string, ParameterValueState>;
+/**
+ * The parameters a room reads, split for `useDevicePresetValues`: live readings and states poll
+ * fast, settings poll slowly. Command steps are written, never read.
+ */
+export declare function coldRoomParameterIds(bindings: ColdRoomBindings): {
+    fastIds: string[];
+    slowIds: string[];
+};
+/** Bindings that hold one parameter. */
+export type ColdRoomParameterKey = Exclude<keyof ColdRoomBindings, "alarms" | "commands">;
+/** Every parameter the bindings name, command steps included, each once in binding order. */
+export declare function coldRoomBoundParameterIds(bindings: ColdRoomBindings): string[];
+/**
+ * A binding left out of a copy: a single-parameter binding, an alarm flag (by its source
+ * parameter, so the caller can name it), or a command with any step that has no match.
+ */
+export type DroppedColdRoomBinding = {
+    kind: "parameter";
+    key: ColdRoomParameterKey;
+} | {
+    kind: "alarm";
+    parameterId: string;
+} | {
+    kind: "command";
+    command: ColdRoomCommand;
+};
+/**
+ * The bindings with their parameters replaced by `map`, for copying a room to another
+ * controller. A binding whose parameter maps to null is left out and reported; a command is left
+ * out when any of its steps does not map, so a partial write sequence is never kept. `newId`
+ * gives each copied step its ID. The result is null when the room probe or the setpoint has no
+ * match.
+ */
+export declare function mapColdRoomBindings(bindings: ColdRoomBindings, map: (parameterId: string) => string | null, newId: (id: string) => string): {
+    bindings: ColdRoomBindings | null;
+    dropped: DroppedColdRoomBinding[];
+};
+/** What the room is doing, or null while the bound states are not current. */
+export declare function coldRoomStatus(bindings: ColdRoomBindings, states: States): ColdRoomStatus | null;
+/**
+ * Alarm thresholds as room temperatures. Relative thresholds are offsets from the setpoint: a
+ * positive high offset and a negative low offset. A limit is null while a value it needs is
+ * unknown.
+ */
+export declare function coldRoomAlarmLimits(input: {
+    relative: boolean | null;
+    setpoint: number | null;
+    high: number | null;
+    low: number | null;
+}): {
+    high: number | null;
+    low: number | null;
+};
+/**
+ * The room's alarm limits from current values; absolute unless a relative mode is bound. A limit
+ * that rests on a value kept from an earlier read is unknown.
+ */
+export declare function coldRoomAlarmLimitsFromStates(bindings: ColdRoomBindings, states: States): {
+    high: number | null;
+    low: number | null;
+};
+/**
+ * Active alarms in binding order, including ones kept from an earlier read, which the card marks
+ * stale. `known` is false while any alarm has no current value, so an empty list does not read as
+ * "no alarms" after the readings stop.
+ */
+export declare function coldRoomActiveAlarms(bindings: ColdRoomBindings, states: States): {
+    active: string[];
+    known: boolean;
+};
+/** The ordered writes of a command, or null when the room does not bind it. */
+export declare function coldRoomCommandSteps(bindings: ColdRoomBindings, command: ColdRoomCommand): ParameterWriteValuesInput["items"] | null;
+/** Commands need a current room reading: a stale or missing one hides what they would act on. */
+export declare function coldRoomCommandsAvailable(bindings: ColdRoomBindings, states: States): boolean;
+/** The commands to offer: on and off follow the stand-by state when it is known. */
+export declare function coldRoomOfferedCommands(bindings: ColdRoomBindings, states: States): ColdRoomCommand[];
+export {};

package/dist/src/workspace/device-presets/command-button.d.ts

@@ -0,0 +1,34 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import type { ParameterWriteSequenceStep } from "@overvis/hmi-shared/parameter";
+import { type ComponentProps, type ReactElement, type ReactNode } from "react";
+import { Button } from "../../ui/button.js";
+import { type ParameterWriteSequenceSecret } from "../parameters/live/write-sequence-dialog.js";
+/**
+ * A device command: a button that opens a confirmation and then writes `steps` in order,
+ * stopping at the first unacknowledged one. Disabled without write access or with `disabled`; an
+ * open confirmation stays open when either changes and cannot start the command then, while a
+ * command already being sent finishes and reports its result. `children`
+ * replaces the list of steps in the confirmation with an explanation of the command.
+ */
+export declare function DeviceCommandButton({ label, steps, secretParameterIds, unlock, locale, icon, variant, size, pressed, disabled, children, onAcknowledged, }: {
+    label: string;
+    /** The writes, or a function that makes them when the command is sent. */
+    steps: readonly ParameterWriteSequenceStep[] | (() => readonly ParameterWriteSequenceStep[]);
+    /** Parameters whose values, such as passwords, are never shown in the list of steps. */
+    secretParameterIds?: readonly string[];
+    /** A password typed in the confirmation and written before `steps`, such as a device unlock. */
+    unlock?: ParameterWriteSequenceSecret;
+    locale: AppLocale;
+    icon?: ReactNode;
+    variant?: ComponentProps<typeof Button>["variant"];
+    size?: ComponentProps<typeof Button>["size"];
+    /** Whether the device is already in the state this command sets; omit when unknown. */
+    pressed?: boolean | undefined;
+    /**
+     * The device would not act on the command now, such as while it is disconnected. The button and
+     * an open confirmation cannot start it; a command already being sent still reports its result.
+     */
+    disabled?: boolean;
+    children?: ReactNode;
+    onAcknowledged?: () => void;
+}): ReactElement;

package/dist/src/workspace/device-presets/endpoint-unavailable.d.ts

@@ -0,0 +1,15 @@
+import type { ReactElement } from "react";
+import type { ParameterDiagnostic } from "../parameters/live/model.js";
+/**
+ * Notice for a device whose connection is down. While live it retries on its own and offers
+ * an immediate retry; while paused it offers to resume. Links to the endpoint status page
+ * when the diagnostic names the endpoint.
+ */
+export declare function DeviceEndpointUnavailable({ diagnostic, workspaceId, live, onRetry, onResume, className, }: {
+    diagnostic: ParameterDiagnostic;
+    workspaceId: string;
+    live: boolean;
+    onRetry: () => void;
+    onResume: () => void;
+    className?: string;
+}): ReactElement;

package/dist/src/workspace/device-presets/gauge-scale.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A reading against one threshold. For a positive threshold and a reading that is not negative,
+ * the gauge starts at zero and the threshold sits at 80 %, so there is room to show a reading above
+ * it, unless the reading is higher still. Otherwise, such as for negative values, the gauge spans
+ * the reading and the threshold with a margin on each side.
+ */
+export declare function thresholdScale(now: number | null, limit: number): {
+    now: number | null;
+    limit: number;
+};
+/**
+ * Readings against a window from `low` to `high`, either of which may be off: the gauge spans the
+ * readings and thresholds with a margin on each side.
+ */
+export declare function windowScale(input: {
+    readings: readonly number[];
+    low: number | null;
+    high: number | null;
+}): {
+    readings: number[];
+    low: number | null;
+    high: number | null;
+};

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

@@ -0,0 +1,52 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+import type { ReactElement, ReactNode } from "react";
+/**
+ * What draft settings do, in a sentence, with an optional gauge of the live reading they act on.
+ * Shown inside a device settings section next to the settings it explains.
+ */
+export declare function DeviceSettingOutcome({ children, gauge, }: {
+    children: ReactNode;
+    gauge?: ReactNode;
+}): ReactElement;
+/**
+ * A live reading against one threshold: the bar fills to the reading, the part past the threshold
+ * is the trip zone, and the tick is the threshold with `limitLabel` above it. A reading kept from
+ * an earlier read is shown muted with its time.
+ */
+export declare function ThresholdGauge({ label, value, staleSince, limit, limitLabel, unit, locale, fractionDigits, }: {
+    /** The reading's name, for assistive technologies. */
+    label: string;
+    value: number | null;
+    staleSince?: number | null;
+    limit: number;
+    /** The tick's text, such as "Trips at 3.67 kW". */
+    limitLabel: string;
+    unit: string;
+    locale: AppLocale;
+    fractionDigits?: number;
+}): ReactElement;
+/** One end of an allowed window: its value and the tick's text, such as "Trips below 320 V". */
+export interface WindowGaugeLimit {
+    value: number;
+    label: string;
+}
+/**
+ * Readings against the window between a low and a high limit, either of which may be off: the
+ * allowed band between the limits, the limits labelled above the track, and the readings marked
+ * and labelled below it. Without either limit there is no window, so it states the readings and
+ * `noLimitsText`. A reading kept from an earlier read is shown muted with its time.
+ */
+export declare function WindowGauge({ label, values, staleSince, low, high, noLimitsText, unit, locale, fractionDigits, }: {
+    /** Shown before the readings, such as "Line voltages now". */
+    label: string;
+    /** The readings, or null while any of them is unknown. */
+    values: readonly number[] | null;
+    staleSince?: number | null;
+    low: WindowGaugeLimit | null;
+    high: WindowGaugeLimit | null;
+    /** Explains why there is no window when both limits are off. */
+    noLimitsText: string;
+    unit: string;
+    locale: AppLocale;
+    fractionDigits?: number;
+}): ReactElement;

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

@@ -0,0 +1,14 @@
+import type { ReactElement, ReactNode } from "react";
+/**
+ * Device photo, title and subtitle, with live controls on the right. Stacks on narrow screens.
+ */
+export declare function DevicePresetHeader({ title, subtitle, image, controls, className, }: {
+    title: ReactNode;
+    subtitle?: ReactNode;
+    image?: {
+        src: string;
+        alt: string;
+    };
+    controls?: ReactNode;
+    className?: string;
+}): ReactElement;

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

@@ -0,0 +1,52 @@
+import { type ReactElement, type ReactNode } from "react";
+import { type DashboardPageTab } from "../dashboards/page-tabs.js";
+/** A page of a device dashboard: its tab and the values it polls while open. */
+export interface DevicePresetPage<Page extends string> extends DashboardPageTab {
+    id: Page;
+    /** Live readings, polled every second. */
+    fastIds: readonly string[];
+    /** Settings and identity values that rarely change. */
+    slowIds: readonly string[];
+    /** How often `slowIds` are read; 30 s by default. */
+    slowIntervalMs?: number;
+}
+/** What the open page of a `DevicePresetLayout` renders with. */
+export interface DevicePresetPageContext<Page extends string> {
+    page: Page;
+    /** The device answers; commands and setting writes wait for it otherwise. */
+    connected: boolean;
+    /** Reads the page's values from the device again. */
+    readAgain: () => void;
+}
+/**
+ * A device dashboard: the device header with live controls, tabs for its pages, the banner of a
+ * disconnected device and other parameter diagnostics, the dashboard's own `notices`, then the
+ * open page. Each page has its own dashboard path, so browser Back returns to the previous page;
+ * an unknown path links to the first page. Only the open page's values are polled.
+ */
+export declare function DevicePresetLayout<Page extends string>({ id, title, subtitle, image, workspaceId, dashboardId, pages, optionalIds, notices, children, }: {
+    /** The dashboard's `data-context-widget` name. */
+    id: string;
+    title: ReactNode;
+    subtitle?: ReactNode;
+    image?: {
+        src: string;
+        alt: string;
+    };
+    workspaceId: string;
+    dashboardId: string;
+    /** The pages in tab order; the first is the dashboard's home. */
+    pages: readonly DevicePresetPage<Page>[];
+    /**
+     * Registers some firmware versions of the device do not have. A read of only these that the
+     * device answers with Modbus exception 2 is shown where they are read, as not supported, instead
+     * of as a diagnostic; the same answer for any other parameter is still reported.
+     */
+    optionalIds?: readonly string[];
+    /**
+     * Banners about the device's state that apply on every page, such as a mode left on that the
+     * operator should end. Their values belong in every page's polled ids.
+     */
+    notices?: (context: DevicePresetPageContext<Page>) => ReactNode;
+    children: (context: DevicePresetPageContext<Page>) => ReactNode;
+}): ReactElement;

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

@@ -0,0 +1,103 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import type { ReactElement, ReactNode } from "react";
+/**
+ * One part of a device page in a card: an icon, a title, an optional description and an action
+ * such as a selector, then the content. Its header matches a settings section's.
+ */
+export declare function DevicePanel({ id, icon, title, description, action, className, contentClassName, children, }: {
+    /** The card's `data-context-widget` name and the base of its heading id. */
+    id: string;
+    icon: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    /** Shown at the end of the header, such as a choice of what a chart shows. */
+    action?: ReactNode;
+    className?: string;
+    contentClassName?: string;
+    children: ReactNode;
+}): ReactElement;
+/** The swatch of series `index` of a device trend; phase L1, L2 and L3 are 0, 1 and 2. */
+export declare function DeviceSeriesSwatch({ index }: {
+    index: number;
+}): ReactElement;
+/**
+ * A headline reading in a small card: its label with an icon, then either one large value with a
+ * trend of the last minute, or the values of the three phases side by side with their swatches.
+ */
+export declare function DeviceKeyFigure({ icon, label, locale, fractionDigits, unit: unitOverride, ...reading }: {
+    icon: ReactNode;
+    label: string;
+    locale: AppLocale;
+    /** Decimals to show; the parameter's own formatting by default. */
+    fractionDigits?: number;
+    /** The unit to show, such as one configured on a binding; the parameter's own when empty. */
+    unit?: string;
+} & ({
+    parameterId: string;
+    trend?: boolean;
+} | {
+    /** L1, L2 and L3, sharing the unit of the first. */
+    phases: readonly [string, string, string];
+    phaseLabels?: readonly [string, string, string];
+})): ReactElement;
+/** One quantity of a phase table: its name and the parameters of L1, L2 and L3. */
+export interface DevicePhaseRow {
+    key: string;
+    label: string;
+    phases: readonly [string, string, string];
+    /** The device's total of the three phases, shown in the total column. */
+    total?: string | null;
+    /** Decimals to show; the parameter's own formatting by default. */
+    fractionDigits?: number;
+}
+/**
+ * Readings of three phases side by side, one row per quantity, each phase marked with its trend
+ * swatch. With `totalLabel`, a shaded last column holds the totals that rows name.
+ */
+export declare function DevicePhaseTable({ label, quantityLabel, rows, locale, phaseLabels, totalLabel, }: {
+    /** The table's accessible name. */
+    label: string;
+    /** Names the column of quantity names for screen readers, such as "Quantity". */
+    quantityLabel: string;
+    rows: readonly DevicePhaseRow[];
+    locale: AppLocale;
+    phaseLabels?: readonly [string, string, string];
+    /** The total column's heading: a short `text`, such as Σ, and its `title`. */
+    totalLabel?: {
+        text: string;
+        title: string;
+    };
+}): ReactElement;
+/** One reading of a `DeviceReadingList`. */
+export interface DeviceReadingItem {
+    key: string;
+    label: ReactNode;
+    parameterId: string;
+    /** Decimals to show; the parameter's own formatting by default. */
+    fractionDigits?: number;
+}
+/**
+ * Readings as rows of a name and a value with its unit, aligned like the rows of a phase table. A
+ * `title` heads the list; lists side by side in a grid keep their rows level.
+ */
+export declare function DeviceReadingList({ title, items, locale, }: {
+    title?: ReactNode;
+    items: readonly DeviceReadingItem[];
+    locale: AppLocale;
+}): ReactElement;
+/** What a status badge says about the device: fine, needs attention, a fault, off, or unknown. */
+export type DeviceStatusTone = "ok" | "warning" | "fault" | "off" | "unknown";
+/** A device state as a tinted badge with a dot, such as "Recording" or "Load relay closed". */
+export declare function DeviceStatusBadge({ tone, title, children, }: {
+    tone: DeviceStatusTone;
+    /** Extra detail, such as when a stale state was read: a tooltip, and read out after the text. */
+    title?: string;
+    children: ReactNode;
+}): ReactElement;
+/** A row of status badges for the whole device, with an `aside` such as the uptime at its end. */
+export declare function DeviceStatusBar({ label, aside, children, }: {
+    /** The bar's accessible name. */
+    label: string;
+    aside?: ReactNode;
+    children: ReactNode;
+}): ReactElement;

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

@@ -0,0 +1,5 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+/** A quantity with its unit, such as "3.67 kW"; without a unit, the number alone. */
+export declare function formatQuantity(value: number, unit: string, locale: AppLocale, maximumFractionDigits?: number): string;
+/** A number at exactly `fractionDigits` places, with the language's decimal separator. */
+export declare function formatFixedNumber(value: number, locale: AppLocale, fractionDigits: number): string;

package/dist/src/workspace/device-presets/relay-test-panel.d.ts

@@ -0,0 +1,37 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import { type ReactElement, type ReactNode } from "react";
+import { type DeviceRelayTestRelay, type DeviceRelayTestRemote } from "./relay-test.js";
+/** A relay's state words, such as "Energized" and "Fault signalled" for a fail-safe fault relay. */
+export interface DeviceRelayTestRelayOptions extends DeviceRelayTestRelay {
+    onLabel?: string;
+    offLabel?: string;
+}
+/**
+ * A relay test over the device's remote relay control. Start opens a confirmation with
+ * `warning`; it hands the relays to remote control and then commands each to the position it held.
+ * Until those commands arrive the device applies its old command values, so a relay may switch
+ * briefly, as the confirmation says. While the test runs, each relay has a switch, and its state is read back from the
+ * device. End test restores the remote-control code the device had before, then each relay's
+ * command register. The test refuses to start
+ * while the relays are already under remote control, ends by itself when the device takes control
+ * back, and asks to be ended before the page is left. The test is kept in the browser under
+ * `storageKey` from its first write, so a reload finds it again with End test. Poll `remote.parameterId`
+ * and every relay's state and command register while it is shown.
+ */
+export declare function DeviceRelayTest({ title, description, warning, relays, remote, locale, canWrite, connected, storageKey, }: {
+    title: string;
+    description: string;
+    /**
+     * Where the browser keeps a running test, one per dashboard and workspace, so a reload can still
+     * end it. It is
+     * required: a test a reload forgot would leave the device's protection suspended.
+     */
+    storageKey: string;
+    /** What the test suspends on this device, shown in the start confirmation. */
+    warning: ReactNode;
+    relays: readonly DeviceRelayTestRelayOptions[];
+    remote: DeviceRelayTestRemote;
+    locale: AppLocale;
+    canWrite: boolean;
+    connected: boolean;
+}): ReactElement;