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

package/dist/src/workspace/graphics/symbols/electrical/presentation.d.ts

@@ -0,0 +1,132 @@
+import { type ComponentProps, type ReactNode } from "react";
+import { Reading } from "../quality.js";
+/** Muted text for a state that cannot be determined; the unknown status color is too pale. */
+export declare const powerUnknownText = "#64748b";
+/** A known fault or warning outranks an unavailable operating state. */
+export declare function powerColor(active: boolean, fault?: boolean, warning?: boolean, unknown?: boolean): "#159b78" | "#94a3b8" | "#cbd5e1" | "#d49a38" | "#dc5656";
+export declare function PowerIndicator({ x, y, active, fault, warning, unknown, }: {
+    x: number;
+    y: number;
+    active: boolean;
+    fault?: boolean;
+    warning?: boolean;
+    /** The operating state is unavailable; a known fault or warning still shows. */
+    unknown?: boolean;
+}): import("react").JSX.Element;
+/** A labelled, positioned numeric readout; see `Reading` for units and quality. */
+export declare function PowerReading({ x, y, label, ...reading }: {
+    x: number;
+    y: number;
+    label: string;
+} & ComponentProps<typeof Reading>): import("react").JSX.Element | null;
+/**
+ * Electrical artwork in its authored units. `padX`/`padY` add margin on both sides, so connection
+ * stubs can reach grid-aligned box edges without redrawing the equipment.
+ */
+export declare function PowerFrame({ width, height, children, padX, padY, }: {
+    width: number;
+    height: number;
+    children: ReactNode;
+    padX?: number;
+    padY?: number;
+}): import("react").JSX.Element;
+/**
+ * The state text of a status line and its colour. A generic fault leads the operating state, as in
+ * "Fault · Charging"; `faultLabel` names a specific fault instead. In the warning state `label` is
+ * shown as given, so pass a text that names the warning or joins it with the operating state
+ * (`graphicsStatusText`); without it a warning reads "Warning · Running".
+ */
+export declare function powerStatusText({ active, fault, warning, unknown, label, faultLabel, }: {
+    active: boolean;
+    fault: boolean;
+    warning?: boolean;
+    unknown?: boolean;
+    label?: string | undefined;
+    faultLabel?: string | undefined;
+}): {
+    text: string;
+    fill: string;
+};
+/**
+ * Whether a reading is due: an essential reading always is, an optional one once the placement
+ * binds or sets it. One hook for any number of readings, so layouts can close up left-out lines.
+ */
+export declare function usePowerReadingShown(): (property: string) => boolean;
+/** A labelled reading of a caption line; the label is required so no value relies on position. */
+export type PowerLineReading = ComponentProps<typeof Reading> & {
+    label: string;
+};
+/**
+ * Labelled readings of one line joined by " · ", as in "I 8.4 A · Load 72 %". Readings the
+ * placement neither binds nor sets are left out with their separator.
+ */
+export declare function PowerReadingSpans({ readings }: {
+    readings: readonly PowerLineReading[];
+}): import("react").JSX.Element[];
+/** One line of the family's caption block; lines that are `false`, `null` or empty are left out. */
+export type PowerCaptionLine = {
+    key: string;
+    content: ReactNode;
+    fill?: string;
+    fontSize?: number;
+} | false | null | undefined;
+/** The equipment tag line, such as "QF1" or "T1", a step larger than the state and readings. */
+export declare function powerTagLine(tag: string): PowerCaptionLine;
+/** The status line, coloured by state; see `powerStatusText`. */
+export declare function powerStateLine(status: Parameters<typeof powerStatusText>[0]): PowerCaptionLine;
+/** A line of labelled readings, left out while none of them is shown. */
+export declare function usePowerReadingLine(key: string, readings: readonly PowerLineReading[]): PowerCaptionLine;
+/**
+ * The family's text block below the artwork, in a fixed order: the equipment tag, the status
+ * line, then labelled readings. Lines are `step` apart from `y` down; left-out lines close up. When
+ * a quarter turn makes the bottom strip vertical, the block moves outside the placement, like a
+ * caption. `width`, `height`, `left` and `top` describe the SVG viewBox.
+ */
+export declare function PowerCaptions({ width, height, left, top, x, y, step, lines, }: {
+    width: number;
+    height: number;
+    left?: number;
+    top?: number;
+    x?: number;
+    y: number;
+    step?: number;
+    lines: readonly PowerCaptionLine[];
+}): import("react").JSX.Element;
+/**
+ * One line of state text. `tag` leads it in the neutral text color; a `reading`, shown once the
+ * placement binds or sets it, or other `children` follow the state after a separator. One `<text>`
+ * keeps the line together when the symbol is turned.
+ */
+export declare function PowerStatus({ x, y, active, fault, warning, unknown, label, faultLabel, tag, reading, children, }: {
+    x: number;
+    y: number;
+    active: boolean;
+    fault: boolean;
+    warning?: boolean;
+    unknown?: boolean;
+    /**
+     * State text. A generic fault leads it, as in "Fault · Charging". In the warning state it is
+     * shown as given, so pass a text that names the warning or joins it with the operating state
+     * (`graphicsStatusText`); without it a warning reads "Warning · Running".
+     */
+    label?: string;
+    /** Names a specific fault, such as a jam. */
+    faultLabel?: string;
+    tag?: string;
+    reading?: ComponentProps<typeof Reading> | undefined;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * A battery outline filled to `charge` percent, its terminal on the right or, when `vertical`, on
+ * top. An unavailable charge draws a dashed outline with an unknown mark instead of a level, and an
+ * optional charge the placement neither binds nor sets draws the outline alone.
+ */
+export declare function PowerChargeGauge({ x, y, width, height, charge, property, vertical, }: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    charge: number;
+    property?: string;
+    vertical?: boolean;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/symbols/electrical/renewables.d.ts

@@ -0,0 +1,2 @@
+export declare const solarArray: import("../definition.js").GraphicsSymbolDefinition;
+export declare const solarInverter: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/electrical/storage.d.ts

@@ -0,0 +1,2 @@
+export declare const ups: import("../definition.js").GraphicsSymbolDefinition;
+export declare const batteryStorage: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/electrical/supply.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../definition.js").GraphicsSymbolDefinition;
+export default _default;

package/dist/src/workspace/graphics/symbols/electrical/switchgear.d.ts

@@ -0,0 +1,61 @@
+import type { ReactNode } from "react";
+/**
+ * Switching devices share one box: 160 × 120 with the conductor on the family's centerline, 60 from
+ * the top, contacts from a pivot at x 40 to a fixed contact at x 100, and captions below.
+ */
+export declare const switchGeometry: {
+    readonly width: 160;
+    readonly height: 120;
+    readonly stretch: false;
+    /** The contacts, so the data-quality badge sits beside them rather than in the empty corner. */
+    readonly body: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+};
+export declare const switchPorts: {
+    readonly input: {
+        readonly id: "input";
+        readonly x: 0;
+        readonly y: 0.5;
+        readonly role: "electrical";
+        readonly direction: "in";
+    };
+    readonly output: {
+        readonly id: "output";
+        readonly x: 1;
+        readonly y: 0.5;
+        readonly role: "electrical";
+        readonly direction: "out";
+    };
+};
+/** Moving contact positions; a tripped breaker's blade stops between closed and open. */
+export declare const switchBlade: {
+    readonly closed: "M40 60H100";
+    readonly open: "M40 60L88 32";
+    readonly tripped: "M40 60L90 46";
+};
+/** An earthed conductor is dead: a dark neutral, never the operating green. */
+export declare const powerEarthedColor = "#475569";
+/**
+ * A switching device drawn on the family's centerline: line-side conductor, pivot and moving
+ * contact, the fixed contact's `qualifier` and load side, then the status mark, interlock and
+ * captions. `position` is the drawn blade, or null while it is unknown.
+ */
+export declare function SwitchArtwork({ position, color, qualifier, alarm, locked, tag, state, stateFill, }: {
+    position: keyof typeof switchBlade | null;
+    color: string;
+    qualifier: ReactNode;
+    alarm: boolean;
+    locked?: boolean;
+    tag: string;
+    state: string;
+    stateFill: string;
+}): import("react").JSX.Element;
+export declare const disconnector: import("../definition.js").GraphicsSymbolDefinition;
+export declare const contactor: import("../definition.js").GraphicsSymbolDefinition;
+export declare const earthingSwitch: import("../definition.js").GraphicsSymbolDefinition;
+export declare const fuse: import("../definition.js").GraphicsSymbolDefinition;
+export declare const automaticTransferSwitch: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/food/filling.d.ts

@@ -0,0 +1 @@
+export declare const fillingStation: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/food/index.d.ts

@@ -0,0 +1 @@
+export declare const foodBeverageGraphicsSymbols: import("../definition.js").GraphicsSymbolDefinition[];

package/dist/src/workspace/graphics/symbols/food/vessel.d.ts

@@ -0,0 +1 @@
+export declare const processVessel: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/fuel-gas/gas-detector.d.ts

@@ -0,0 +1 @@
+export declare const gasDetector: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/fuel-gas/index.d.ts

@@ -0,0 +1 @@
+export declare const fuelGasGraphicsSymbols: import("../definition.js").GraphicsSymbolDefinition[];

package/dist/src/workspace/graphics/symbols/handles.d.ts

@@ -0,0 +1,6 @@
+import { type GraphicsElement } from "@overvis/hmi-shared/graphics";
+export declare function GraphicsPorts({ element, editing, selected, }: {
+    element: GraphicsElement;
+    editing: boolean;
+    selected: boolean;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/symbols/hvac/air-handling.d.ts

@@ -0,0 +1,4 @@
+export declare const fan: import("../definition.js").GraphicsSymbolDefinition;
+export declare const damper: import("../definition.js").GraphicsSymbolDefinition;
+export declare const airFilter: import("../definition.js").GraphicsSymbolDefinition;
+export declare const airCoil: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/hvac/air-section.d.ts

@@ -0,0 +1,60 @@
+import { type GraphicsReadingEntry } from "../quality.js";
+import { type OperatingState } from "./presentation.js";
+/**
+ * The air-handling duct section on a 200-unit box: the duct runs on `center`, housings span `left`
+ * to `right` and `top` to `bottom`, and readouts sit on the `readings` rows below. Components drawn
+ * to it line up as one unit casing when placed side by side.
+ */
+export declare const airSection: {
+    readonly center: 80;
+    readonly duct: 24;
+    readonly left: 40;
+    readonly right: 160;
+    readonly top: 30;
+    readonly bottom: 130;
+    readonly readings: readonly [150, 163];
+};
+/** The housing of a component drawn to the air-handling section, as fractions of its box. */
+export declare const airSectionBody: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * A duct stub of the air-handling section between `from` and `to`. Its ends are square, so a stub
+ * ending on the box edge meets the next component's stub without a seam.
+ */
+export declare function Duct({ from, to, y, }: {
+    from: number;
+    to: number;
+    y?: number;
+}): import("react").JSX.Element;
+/** Ducts on both sides and the unit casing between them, drawn to the air-handling section. */
+export declare function AirCasing({ width, left, right, top, bottom, ducts, }: {
+    width?: number;
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+    ducts?: readonly number[];
+}): import("react").JSX.Element;
+/**
+ * Rows of labelled readings from `top` down. A row with nothing to show collapses, so the rows
+ * that remain keep their order without a gap.
+ */
+export declare function ReadingRows({ rows, x, top, step, }: {
+    rows: readonly (readonly GraphicsReadingEntry[])[];
+    x?: number;
+    top?: number;
+    step?: number;
+}): import("react").JSX.Element[];
+/** Large shapes keep a neutral tone in normal operation and take the colour of an alarm. */
+export declare function alarmTone(state: OperatingState, neutral: string): string;
+/** An airflow arrow inside a duct stub. */
+export declare function FlowArrow({ x, y, direction, color, }: {
+    x: number;
+    y: number;
+    direction: 1 | -1;
+    color: string;
+}): import("react").JSX.Element;

package/dist/src/workspace/graphics/symbols/hvac/air-terminals.d.ts

@@ -0,0 +1,2 @@
+export declare const airTerminal: import("../definition.js").GraphicsSymbolDefinition;
+export declare const fanCoil: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/hvac/air-treatment.d.ts

@@ -0,0 +1,2 @@
+export declare const heatRecovery: import("../definition.js").GraphicsSymbolDefinition;
+export declare const humidityUnit: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/hvac/circuit.d.ts

@@ -0,0 +1,45 @@
+import type { ReactNode } from "react";
+import { type OperatingProperties, type OperatingState } from "./presentation.js";
+/** A supply or return nozzle stub from `from` to `to` on one line, with its mark above it. */
+export declare function Nozzle({ y, from, to, kind, marked, }: {
+    y: number;
+    from: number;
+    to: number;
+    kind: "supply" | "return";
+    marked?: boolean;
+}): import("react").JSX.Element;
+/**
+ * Supply and return temperatures under one label: "Flow/return 45/35 °C" when both show, the
+ * supply or return label alone when only one does.
+ */
+export declare function SupplyReturn({ supply, back }: {
+    supply: number;
+    back: number;
+}): import("react").JSX.Element;
+/** Reading rows under the artwork; rows without an assigned reading are left out. */
+export declare function ReadingRows({ top, rows }: {
+    top: number;
+    rows: readonly (ReactNode | null)[];
+}): import("react").JSX.Element[];
+/**
+ * Status of equipment with an operating mode. Once the placement assigns the mode, the mode names
+ * the operating state and decides whether the equipment is operating; a lockout raises the fault
+ * by itself. Known fault and warning flags lead, joined to the mode: "Fault · Firing". Unavailable
+ * running feedback or mode is unknown.
+ */
+export declare function useModeStatus(p: Pick<OperatingProperties, "running" | "fault" | "warning">, mode: {
+    name: string;
+    active: boolean;
+    lockout?: boolean;
+}): {
+    state: OperatingState;
+    status: string | undefined;
+    alarmStatus: string | undefined;
+    alarmJoins: boolean;
+    shown: boolean;
+    modeUnknown: boolean;
+};
+/** `count` evenly spaced values from `start` to `end`. */
+export declare function spread(start: number, end: number, count: number): number[];
+/** Neutral artwork in normal operation; the alarm colour only while a warning or fault is raised. */
+export declare function alarmStroke(state: OperatingState, normal?: string): string;

package/dist/src/workspace/graphics/symbols/hvac/cooling-plant.d.ts

@@ -0,0 +1,2 @@
+export declare const chiller: import("../definition.js").GraphicsSymbolDefinition;
+export declare const coolingTower: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/hvac/firing.d.ts

@@ -0,0 +1,2 @@
+export declare const boiler: import("../definition.js").GraphicsSymbolDefinition;
+export declare const burner: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/hvac/hydronic.d.ts

@@ -0,0 +1,5 @@
+export declare const heatexchanger: import("../definition.js").GraphicsSymbolDefinition;
+export declare const heatPump: import("../definition.js").GraphicsSymbolDefinition;
+export declare const hotWaterTank: import("../definition.js").GraphicsSymbolDefinition;
+export declare const radiator: import("../definition.js").GraphicsSymbolDefinition;
+export declare const expansionVessel: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/hvac/index.d.ts

@@ -0,0 +1,2 @@
+export declare const hvacGraphicsSymbols: import("../definition.js").GraphicsSymbolDefinition[];
+export { FanWheel, Frame, HeatLine, OvertemperatureMark, Pipe, Readout, inlinePorts, operatingExamples, operatingProperties, useOperatingColor, useOperatingState, useOvertemperature, type OperatingState, } from "./presentation.js";

package/dist/src/workspace/graphics/symbols/hvac/instruments.d.ts

@@ -0,0 +1,5 @@
+export declare const heatMeter: import("../definition.js").GraphicsSymbolDefinition;
+export declare const environmentSensor: import("../definition.js").GraphicsSymbolDefinition;
+export declare const temperatureProbe: import("../definition.js").GraphicsSymbolDefinition;
+export declare const temperatureController: import("../definition.js").GraphicsSymbolDefinition;
+export declare const thermalZone: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/hvac/presentation.d.ts

@@ -0,0 +1,162 @@
+import { graphicsStatusColors } from "../quality.js";
+import Type, { type Static } from "typebox";
+import type { ReactNode } from "react";
+export declare const operatingProperties: () => {
+    label: Type.TString;
+    running: Type.TBoolean;
+    fault: Type.TBoolean;
+    warning: Type.TBoolean;
+    animate: Type.TBoolean;
+    showReadings: Type.TBoolean;
+};
+declare const _operatingType: () => Type.TObject<{
+    label: Type.TString;
+    running: Type.TBoolean;
+    fault: Type.TBoolean;
+    warning: Type.TBoolean;
+    animate: Type.TBoolean;
+    showReadings: Type.TBoolean;
+}>;
+export type OperatingProperties = Static<ReturnType<typeof _operatingType>>;
+export type OperatingState = keyof typeof graphicsStatusColors;
+/**
+ * Known fault and warning flags outrank an unavailable running state; an unavailable flag shows
+ * nothing alarming. `runningProperty` names the property `p.running` was read from.
+ */
+export declare function useOperatingState(p: Pick<OperatingProperties, "running" | "fault" | "warning">, runningProperty?: string): OperatingState;
+export declare function useOperatingColor(p: OperatingProperties, runningProperty?: string): "#159b78" | "#94a3b8" | "#cbd5e1" | "#d49a38" | "#dc5656";
+export declare function useOperatingTextColor(p: OperatingProperties): string;
+/**
+ * Artwork on a 200-unit square by default; other sizes pass their actual size. The tag and status
+ * lines take the bottom 34 units. `state` replaces the state derived from `properties`, `status`
+ * names the operating and inactive states, and `alarmStatus` the warning and fault states; an
+ * alarm leads the operating state, as in "Warning · Heating". `tone` sets the status the marker and
+ * text show when it differs from `state`, such as a fault-coloured high alarm; `mark` replaces the
+ * marker entirely. `markerX` moves the status marker for narrow artwork. The
+ * status line shows once the placement binds or sets running, or while a bound fault or warning
+ * is raised; `statusShown` decides instead for equipment with other state inputs. An alarm joins the operating text while
+ * the equipment runs; `alarmJoins` decides instead for equipment whose `status` is not about
+ * running, such as a damper's end position.
+ */
+export declare function Frame({ properties, children, status, alarmStatus, state: override, tone, markerX, width, height, statusShown, alarmJoins, mark, }: {
+    properties: Pick<OperatingProperties, "label" | "running" | "fault" | "warning">;
+    children: ReactNode;
+    status?: string | undefined;
+    alarmStatus?: string | undefined;
+    state?: OperatingState;
+    tone?: OperatingState | undefined;
+    markerX?: number;
+    width?: number;
+    height?: number;
+    statusShown?: boolean;
+    alarmJoins?: boolean;
+    /** Draws the status marker at `x, y` instead of the standard mark, for states it cannot name. */
+    mark?: ((x: number, y: number) => ReactNode) | undefined;
+}): import("react").JSX.Element;
+/** A pipe run: "water" is also a circuit's cooler return, "hot" its supply, "gas" a fuel line. */
+export declare function Pipe({ d, media, }: {
+    d: string;
+    media?: "water" | "air" | "hot" | "gas";
+}): import("react").JSX.Element;
+export declare function Readout({ x, y, children, }: {
+    x?: number;
+    y?: number;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function FanWheel({ properties, runningProperty, x, y, radius, impeller, }: {
+    properties: OperatingProperties;
+    /** The property `properties.running` was read from. */
+    runningProperty?: string;
+    x?: number;
+    y?: number;
+    radius?: number;
+    /** A three-blade propeller, or a centrifugal wheel of many short curved blades. */
+    impeller?: "axial" | "centrifugal";
+}): import("react").JSX.Element;
+/** Inlet on the left, outlet on the right, on one process line. */
+export declare function inlinePorts(role: "process" | "air"): ({
+    id: string;
+    x: number;
+    y: number;
+    role: "air" | "process";
+    direction: "in";
+} | {
+    id: string;
+    x: number;
+    y: number;
+    role: "air" | "process";
+    direction: "out";
+})[];
+/** Two circuits; nozzles keep their distance from the top and bottom when stretched. */
+export declare const circuitPorts: ({
+    id: string;
+    x: number;
+    y: number;
+    anchorY: "start";
+    role: "process";
+    direction: "in";
+} | {
+    id: string;
+    x: number;
+    y: number;
+    anchorY: "end";
+    role: "process";
+    direction: "out";
+} | {
+    id: string;
+    x: number;
+    y: number;
+    anchorY: "end";
+    role: "process";
+    direction: "in";
+} | {
+    id: string;
+    x: number;
+    y: number;
+    anchorY: "start";
+    role: "process";
+    direction: "out";
+})[];
+export declare function operatingExamples(activeProperties?: Record<string, string | number | boolean>): ({
+    id: string;
+    name: string;
+    properties: {
+        running: boolean;
+        fault?: never;
+    };
+} | {
+    id: string;
+    name: string;
+    properties: {
+        running: boolean;
+        warning: boolean;
+        fault?: never;
+    };
+} | {
+    id: string;
+    name: string;
+    properties: {
+        running?: never;
+        fault: boolean;
+    };
+} | {
+    id: string;
+    name: string;
+    properties: {
+        fault?: never;
+        running: boolean;
+        showReadings: boolean;
+    };
+})[];
+/** A bound overtemperature trip that is known to be active; an unavailable flag shows nothing. */
+export declare function useOvertemperature(overtemperature: boolean): boolean;
+/** A red thermometer beside the equipment for a tripped overtemperature limit. */
+export declare function OvertemperatureMark({ x, y }: {
+    x: number;
+    y: number;
+}): import("react").JSX.Element;
+/** Heat passed on to the equipment it serves, as the burner draws its flame outlet. */
+export declare function HeatLine({ d }: {
+    d: string;
+}): import("react").JSX.Element;
+export {};

package/dist/src/workspace/graphics/symbols/manufacturing/actuators.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+export declare const cylinder: import("../definition.js").GraphicsSymbolDefinition;
+/** Two pitched blades seen from the side; turning, they sweep through the shaft line. */
+export declare function Impeller({ x, y, turned, moving, color, }: {
+    x: number;
+    y: number;
+    /** The shaft is horizontal. */
+    turned: boolean;
+    moving: boolean;
+    color: string;
+}): import("react").JSX.Element;
+/** A drive motor box marked M, outlined in its state color. */
+export declare function Motor({ x, y, width, height, color, }: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+}): ReactNode;
+export declare const agitator: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/manufacturing/conveyor.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentProps, ReactNode } from "react";
+import { Reading } from "../quality.js";
+/**
+ * Production-line equipment carries material 40 units above its bottom edge, so a conveyor, a
+ * machine and the next conveyor standing on one floor line connect with straight lines.
+ */
+export declare const materialLineHeight = 40;
+/** The conveyor belt's thickness; belt stubs through machines match it so edges line up. */
+export declare const beltThickness = 20;
+/** A stretch of belt passing through a machine, drawn with its centerline at `y`. */
+export declare function BeltStub({ from, to, y, color, thickness, }: {
+    from: number;
+    to: number;
+    y: number;
+    color: string;
+    /** Pass `beltThickness` where the stub meets a conveyor. */
+    thickness?: number;
+}): import("react").JSX.Element;
+/**
+ * A reading with its label for the end of a status line, or undefined while the placement neither
+ * binds nor sets it, so the status line drops its separator too.
+ */
+export declare function useStatusReading(show: boolean, label: string, reading: ComponentProps<typeof Reading>): ReactNode;
+/** Whether a known jam or fault stops the equipment; an unavailable flag alarms nothing. */
+export declare function useKnownFlag(property: string, value: boolean): boolean;
+export declare const conveyor: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/manufacturing/index.d.ts

@@ -0,0 +1,3 @@
+export declare const manufacturingGraphicsSymbols: import("../definition.js").GraphicsSymbolDefinition[];
+export { Impeller, Motor } from "./actuators.js";
+export { BeltStub, beltThickness, materialLineHeight, useKnownFlag, useStatusReading, } from "./conveyor.js";

package/dist/src/workspace/graphics/symbols/manufacturing/indicators.d.ts

@@ -0,0 +1,2 @@
+export declare const presenceSensor: import("../definition.js").GraphicsSymbolDefinition;
+export declare const stackLight: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/manufacturing/stations.d.ts

@@ -0,0 +1,3 @@
+export declare const machine: import("../definition.js").GraphicsSymbolDefinition;
+export declare const robotCell: import("../definition.js").GraphicsSymbolDefinition;
+export declare const inspectionStation: import("../definition.js").GraphicsSymbolDefinition;

package/dist/src/workspace/graphics/symbols/ports.d.ts

@@ -0,0 +1,12 @@
+import { type GraphicsElement, type GraphicsPortSide } from "@overvis/hmi-shared/graphics";
+import { type GraphicsSymbolDefinition } from "./definition.js";
+interface ElementPort {
+    id: string;
+    x: number;
+    y: number;
+    /** The edge the port faces in the unrotated element box; null for a junction's center. */
+    side: GraphicsPortSide | null;
+}
+/** Ports normalized to the unrotated element box, following symbol fitting and mirroring. */
+export declare function graphicsElementPorts(element: GraphicsElement, symbols: ReadonlyMap<string, GraphicsSymbolDefinition>): ElementPort[];
+export {};

package/dist/src/workspace/graphics/symbols/preferences.d.ts

@@ -0,0 +1,27 @@
+import Type, { type Static } from "typebox";
+declare const preferencesType: Type.TObject<{
+    favorites: Type.TArray<Type.TObject<{
+        symbolId: Type.TString;
+        workspaceId: Type.TOptional<Type.TString>;
+    }>>;
+    recents: Type.TArray<Type.TObject<{
+        symbolId: Type.TString;
+        workspaceId: Type.TOptional<Type.TString>;
+    }>>;
+}>;
+export type GraphicsSymbolPreferences = Static<typeof preferencesType>;
+export declare const graphicsSymbolRecentLimit = 12;
+export declare function graphicsSymbolPreferencesKey(userId: string): string;
+export declare function toggleGraphicsSymbolFavorite(preferences: GraphicsSymbolPreferences, symbolId: string, workspaceId: string): GraphicsSymbolPreferences;
+export declare function recordGraphicsSymbolRecent(preferences: GraphicsSymbolPreferences, symbolId: string, workspaceId: string): GraphicsSymbolPreferences;
+/**
+ * Favorite and recently inserted symbols of the signed-in user in this browser. Built-in symbols
+ * are shared by every workspace; workspace symbols stay with the workspace that defines them.
+ */
+export declare function useGraphicsSymbolPreferences(workspaceId: string): {
+    favorites: Set<string>;
+    recents: string[];
+    toggleFavorite: (symbolId: string) => void;
+    recordRecent: (symbolId: string) => void;
+};
+export {};

package/dist/src/workspace/graphics/symbols/preview.d.ts

@@ -0,0 +1,8 @@
+import { type GraphicsSymbolDefinition } from "./definition.js";
+/** Render authored dimensions, then uniformly fit the complete React content into the tile. */
+export declare function GraphicsSymbolPreview({ definition, properties, size, }: {
+    definition: GraphicsSymbolDefinition;
+    /** Property values to show, such as a variant or an example state. */
+    properties?: Readonly<Record<string, string | number | boolean>>;
+    size?: "tile" | "large" | "small";
+}): import("react").JSX.Element;