@camstack/ui-library 0.1.57 → 0.2.0

package/dist/composites/data-table.d.ts

@@ -34,4 +34,4 @@ export interface DataTableProps<T> {
     /** Per-row className resolver (e.g. status-coloured backgrounds). */
     readonly rowClassName?: (row: T, rowIndex: number) => string | undefined;
 }
-export declare function DataTable<T>({ columns, rows, rowKey, onRowClick, minWidthPx, emptyMessage, className, bordered, rowClassName, }: DataTableProps<T>): import("react/jsx-runtime").JSX.Element | null;
+export declare function DataTable<T>({ columns, rows, rowKey, onRowClick, minWidthPx, emptyMessage, className, bordered, rowClassName, }: DataTableProps<T>): import("react").JSX.Element | null;

package/dist/composites/detection-canvas.d.ts

@@ -26,4 +26,4 @@ export interface DetectionCanvasProps {
     /** Border width for bboxes in px (default: 2) */
     readonly borderWidth?: number;
 }
-export declare function DetectionCanvas({ src, imageWidth, imageHeight, detections, classColors, aspectRatio, className, placeholder, showConfidence, minConfidence, borderWidth, }: DetectionCanvasProps): import("react/jsx-runtime").JSX.Element;
+export declare function DetectionCanvas({ src, imageWidth, imageHeight, detections, classColors, aspectRatio, className, placeholder, showConfidence, minConfidence, borderWidth, }: DetectionCanvasProps): import("react").JSX.Element;

package/dist/composites/detection-overlay.d.ts

@@ -6,4 +6,4 @@ export interface DetectionOverlayProps {
     readonly showDetections?: boolean;
     readonly showPhaseIndicator?: boolean;
 }
-export declare function DetectionOverlay({ detections: { motion, motionRaw, detection, phase }, showMotionZones, showMotionRaw, showDetections, showPhaseIndicator, }: DetectionOverlayProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DetectionOverlay({ detections: { motion, motionRaw, detection, phase }, showMotionZones, showMotionRaw, showDetections, showPhaseIndicator, }: DetectionOverlayProps): import("react").JSX.Element | null;

package/dist/composites/detection-result-tree.d.ts

@@ -8,4 +8,4 @@ export interface DetectionResultTreeProps {
     /** Callback when a detection's visibility is toggled */
     readonly onToggleVisibility?: (key: string, visible: boolean) => void;
 }
-export declare function DetectionResultTree({ detections, classColors, className, hiddenKeys, onToggleVisibility, }: DetectionResultTreeProps): import("react/jsx-runtime").JSX.Element;
+export declare function DetectionResultTree({ detections, classColors, className, hiddenKeys, onToggleVisibility, }: DetectionResultTreeProps): import("react").JSX.Element;

package/dist/composites/dev-shell.d.ts

@@ -16,5 +16,5 @@ interface DevShellContextValue {
     logout: () => void;
 }
 export declare function useDevShell(): DevShellContextValue;
-export declare function DevShell({ children, serverUrl, title, }: DevShellProps): import("react/jsx-runtime").JSX.Element;
+export declare function DevShell({ children, serverUrl, title }: DevShellProps): import("react").JSX.Element;
 export {};

package/dist/composites/device-activity-panel.d.ts

@@ -1,5 +1,9 @@
 export interface DeviceActivityPanelProps {
     readonly deviceId: number;
+    /** When this device is a Container, its own id — the Logs tab then shows the
+     *  whole subtree (container + every child) by filtering `containerDeviceId`
+     *  instead of `deviceId`. Omit/undefined for a non-container. */
+    readonly containerDeviceId?: number;
     /** Initial event categories the user wants tracked. Defaults to "all". */
     readonly defaultEventCategories?: readonly string[];
     /** Initial state-cap whitelist. Empty = show every cap that fires. */
@@ -25,5 +29,5 @@ declare const TABS: readonly [{
     readonly icon: import('react').ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & import('react').RefAttributes<SVGSVGElement>>;
 }];
 export type ActivityTabId = (typeof TABS)[number]['id'];
-export declare function DeviceActivityPanel({ deviceId, defaultEventCategories, defaultStateCaps, initialTab, className, maxHeight, }: DeviceActivityPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function DeviceActivityPanel({ deviceId, containerDeviceId, defaultEventCategories, defaultStateCaps, initialTab, className, maxHeight, }: DeviceActivityPanelProps): import("react").JSX.Element;
 export {};

package/dist/composites/device-card.d.ts

@@ -35,4 +35,4 @@ export interface DeviceCardProps {
     /** Additional CSS classes */
     className?: string;
 }
-export declare function DeviceCard({ title, subtitle, status, selected, onClick, badges, actions, offlineAction, className, }: DeviceCardProps): import("react/jsx-runtime").JSX.Element;
+export declare function DeviceCard({ title, subtitle, status, selected, onClick, badges, actions, offlineAction, className, }: DeviceCardProps): import("react").JSX.Element;

package/dist/composites/device-controls/alarm-hero-card.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * Row-sized alarm control: the shared Disarm + arm-mode segment strip only —
+ * no glyph, no state label, no card padding. Cap-gated on `alarm-panel`.
+ * Drops into a 200 px control column without towering over sibling rows.
+ */
+export declare function AlarmInlineControl({ trpc, deviceId, optimistic }: DeviceControlProps): ReactNode;
+/**
+ * AlarmHeroCard — segmented arm/disarm hero for AlarmPanel devices.
+ *
+ * Renders (Spec §3):
+ *  - A shield glyph + state label tinted by lifecycle state (disarmed=muted,
+ *    armed=green, arming/pending=amber, triggered=red).
+ *  - The shared `AlarmSegments` strip: a Disarm button plus one arm button per
+ *    `availableModes` entry (Home / Away / Night / …). The currently-active
+ *    segment is highlighted; transitioning states highlight none.
+ *
+ * Cap-gated on `alarm-panel` — returns null when the device lacks the cap.
+ * PIN entry (when `requiresCode`) is deferred to a later task; the segments
+ * call arm/disarm without a code, and the provider rejects when a code is
+ * required — surfaced upstream.
+ */
+export declare function AlarmHeroCard({ trpc, deviceId, optimistic }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/atoms.d.ts

@@ -0,0 +1,81 @@
+import { ComponentPropsWithoutRef, ReactNode } from 'react';
+export declare const FILL: "fill";
+export declare const RIGHT: "right";
+export declare const CENTER: "center";
+export declare const FIT: "fit";
+export type ControlAlign = typeof FILL | typeof RIGHT | typeof CENTER | typeof FIT;
+interface ControlColumnProps extends ComponentPropsWithoutRef<'div'> {
+    readonly align: ControlAlign;
+    readonly children: ReactNode;
+}
+/** The one control column every device-row/hero control sits in.
+ *  FILL → the child stretches to the full fixed column width (steppers, selects, buttons, cover triad).
+ *  RIGHT → the child keeps its natural width, flush to the right edge of the fixed column (readouts, toggles — card view).
+ *  CENTER → the child keeps its natural width, centered in the fixed column (readouts, toggles).
+ *  FIT → the column DROPS its fixed width and sizes to its content (table view). The control takes
+ *        its natural width and lays out in sequence with the trailing trash + status dot, so a wide
+ *        control (climate stepper + mode select, cover triad + %) never overflows a fixed box and
+ *        collides with the neighbours. FILL has no effect under FIT — a stretchy child in a
+ *        content-width wrapper simply takes its natural width.
+ *  FILL, RIGHT and CENTER share the fixed `w-[140px]` box (card / minimal / hero views). */
+export declare function ControlColumn({ align, children, className, ...rest }: ControlColumnProps): ReactNode;
+interface ValueReadoutProps {
+    readonly value: string;
+    readonly unit?: string;
+}
+/** A value + inline unit suffix (no separator). E.g. `60s`, `22%`. */
+export declare function ValueReadout({ value, unit }: ValueReadoutProps): ReactNode;
+interface StepperProps {
+    readonly value: number | string;
+    readonly unit?: string;
+    readonly onDelta: (d: 1 | -1) => void;
+}
+/** Increment/decrement control with value + unit display. */
+export declare function Stepper({ value, unit, onDelta }: StepperProps): ReactNode;
+interface SlideToggleProps {
+    readonly on: boolean;
+    readonly targetLabel: string;
+    readonly onConfirm: () => void;
+}
+/** Safety slide: onConfirm fires only after the thumb is dragged past threshold, never on a plain tap. */
+export declare function SlideToggle({ on, targetLabel, onConfirm }: SlideToggleProps): ReactNode;
+interface ArcKnobProps {
+    readonly fraction: number;
+    readonly color: string;
+    /**
+     * Distance in px from the rotating container's top edge to the knob's top
+     * edge. The knob is 20px tall, so its CENTER sits at `knobTopPx + 10` px
+     * from the top. For the knob center to ride the ring's centre radius the
+     * caller passes `(containerCenter − ringRadius) − 10`. Defaults to the
+     * thermostat gauge value (176px container, radius 76 → 88 − 76 − 10 = 2).
+     */
+    readonly knobTopPx?: number;
+    /**
+     * When provided, the knob becomes interactive: dragging it reports the new
+     * arc fraction (0..1) to the parent, which owns the value and re-renders the
+     * knob at the new `fraction`. When omitted the knob is a display-only
+     * indicator (no grab cursor, no pointer handlers).
+     */
+    readonly onDragFraction?: (fraction: number) => void;
+}
+/** Half the ArcKnob's 20px (h-5) height. Callers seat the knob centre on a
+ *  ring by computing `(containerCentre − ringRadius) − KNOB_HALF_PX`. */
+export declare const KNOB_HALF_PX = 10;
+/**
+ * White knob riding a circular arc at `fraction` (0..1). For thermostat/light/fan.
+ *
+ * Display-only by default. Pass `onDragFraction` to make the knob draggable:
+ * pointer capture is taken on the knob, and pointer moves are mapped to a new
+ * arc fraction reported back to the parent (the parent owns the value).
+ */
+export declare function ArcKnob({ fraction, color, knobTopPx, onDragFraction }: ArcKnobProps): ReactNode;
+interface GripTrackProps {
+    readonly fraction: number;
+    readonly color?: string;
+}
+/**
+ * Horizontal track with a white grip thumb at `fraction` (0..1). For seek/volume/brightness.
+ * @remarks display-only indicator; interactive drag is deferred to a later task.
+ */
+export declare function GripTrack({ fraction, color }: GripTrackProps): ReactNode;
+export {};

package/dist/composites/device-controls/brightness-panel.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from 'react';
+import { ControlPanelProps } from './types';
+export declare function BrightnessPanel({ trpc, deviceId, layout, optimistic, }: ControlPanelProps): ReactNode;

package/dist/composites/device-controls/button-control.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * ButtonControl (inline) — compact "Press" trigger for a device-list row.
+ *
+ * The `button` cap is fire-only (no status / runtimeState), so we bypass
+ * `useDeviceCapability` (which requires a slice) and resolve the cap
+ * handle directly from the device proxy. We guard on `cap === undefined`
+ * (device has no button cap) and render nothing in that case.
+ */
+export declare function ButtonControl({ trpc, deviceId }: DeviceControlProps): ReactNode;
+/**
+ * ButtonHeroCard — large press-actuator card for the device-detail hero area.
+ *
+ * Renders a centred "Press" button with real design-token classes. The cap is
+ * fire-only so no state display is needed — the affordance IS the control.
+ */
+export declare function ButtonHeroCard({ trpc, deviceId }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/climate-panel.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { ControlPanelProps } from './types.js';
+import { HvacMode } from '@camstack/types';
+/**
+ * Exhaustive colour map — one entry per HvacMode. Build will fail if a
+ * mode is added to the enum and not reflected here (Record<HvacMode, ...>
+ * + `satisfies` means TypeScript enforces full coverage).
+ */
+export declare const MODE_COLOR: Record<HvacMode, string>;
+/**
+ * Mode text-accent colour — applied to the compact (inline) temperature value
+ * as a subtle cue, replacing the old bordered/filled mode box so the control
+ * matches the borderless cover/lock inline visual language.
+ */
+export declare const MODE_TEXT_COLOR: Record<HvacMode, string>;
+export declare function ClimatePanel({ trpc, deviceId, features: _features, layout, optimistic, }: ControlPanelProps): ReactNode;

package/dist/composites/device-controls/container-primary-hero.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
+import { ContainerChild } from './container-primary';
+/** A child row the hero can render + offer in the picker. */
+export interface ContainerHeroChild extends ContainerChild {
+    readonly name: string;
+    readonly features?: readonly string[];
+}
+export interface ContainerPrimaryHeroProps {
+    readonly trpc: UseDeviceProxyTrpc;
+    /** The container's entity-children (from `deviceManager.getChildren`). */
+    readonly children: readonly ContainerHeroChild[];
+    /** Container's LEGACY persisted primary-child override (numeric child id) —
+     *  consulted only when no durable `primaryChildEntityId` is set. */
+    readonly linkDeviceId: number | null | undefined;
+    /** Container's DURABLE primary-child override (chosen child's entityId) —
+     *  null/undefined ⇒ no durable override (falls back to linkDeviceId, then
+     *  priority default). */
+    readonly primaryChildEntityId?: string | null | undefined;
+    /** Persist the chosen primary child. Called with the picked child's
+     *  re-sync/rename-stable `entityId`. */
+    readonly onSetPrimary: (childEntityId: string) => void;
+}
+export declare function ContainerPrimaryHero({ trpc, children, linkDeviceId, primaryChildEntityId, onSetPrimary, }: ContainerPrimaryHeroProps): ReactNode;

package/dist/composites/device-controls/container-primary.d.ts

@@ -0,0 +1,46 @@
+import { ChildRef } from './primary-child';
+/**
+ * Minimal shape this module needs from a child device row. Structurally
+ * compatible with `DeviceItemDevice` / `DeviceInfo` — callers pass the raw
+ * `getChildren` rows through.
+ */
+export interface ContainerChild {
+    readonly id: number;
+    readonly stableId: string;
+    readonly type: string;
+    readonly sourceInfo?: {
+        readonly id: string;
+    } | undefined;
+}
+/**
+ * Re-sync-stable identity of a child. Prefers the upstream-system dispatch key
+ * (`sourceInfo.id` — e.g. HA `entity_id`); falls back to `stableId` for
+ * providers that never populated SourceInfo. Both survive a re-sync that may
+ * reallocate the numeric `id`.
+ */
+export declare function childEntityId(child: ContainerChild): string;
+/** Project a raw child row onto the pure resolver's {@link ChildRef} shape. */
+export declare function containerChildToRef(child: ContainerChild): ChildRef;
+/**
+ * Resolve the entityId override from the container's persisted `linkDeviceId`.
+ * Returns the linked child's stable entityId, or `undefined` when there is no
+ * link or the link is stale (points to a numeric id no longer present) — in
+ * which case the resolver falls back to the priority default.
+ */
+export declare function overrideEntityIdFromLink(children: readonly ContainerChild[], linkDeviceId: number | null | undefined): string | undefined;
+/**
+ * Full container → primary-child resolution: project children to refs, resolve
+ * the override entityId, and delegate to the pure resolver. Returns `null` for a
+ * container with no children (caller degrades gracefully).
+ *
+ * Override precedence:
+ *   1. `primaryChildEntityId` — the DURABLE override (re-sync/rename-stable),
+ *      passed straight to the resolver which matches on `entityId`. Wins when a
+ *      non-empty string is supplied.
+ *   2. `linkDeviceId` — LEGACY numeric override, re-derived to an entityId from
+ *      the live child set. Consulted only when there is no durable override.
+ *
+ * When neither resolves to a live child, the resolver falls back to the
+ * priority default.
+ */
+export declare function resolveContainerPrimary(children: readonly ContainerChild[], linkDeviceId: number | null | undefined, primaryChildEntityId?: string | null | undefined): ChildRef | null;

package/dist/composites/device-controls/control-panel.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { ControlPanelProps } from './types.js';
+/** Trim an HA date value to the `<input type=date>` shape ('YYYY-MM-DD'). */
+export declare function toDateInput(value: string): string;
+/** Trim an HA time value ('HH:MM:SS') to the `<input type=time>` shape ('HH:MM'). */
+export declare function toTimeInput(value: string): string;
+/** Trim an HA datetime value to the `<input type=datetime-local>` shape
+ *  ('YYYY-MM-DDTHH:MM'). Accepts both 'T'- and space-separated forms. */
+export declare function toDateTimeInput(value: string): string;
+export declare function ControlPanel({ trpc, deviceId, features: _features, layout, optimistic, }: ControlPanelProps): ReactNode;

package/dist/composites/device-controls/control-registry.d.ts

@@ -0,0 +1,74 @@
+import { ReactNode } from 'react';
+import { DeviceType } from '@camstack/types';
+import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
+import { ControlAlign } from './atoms';
+export { coverHighlight } from './cover-inline';
+export interface DeviceControlProps {
+    readonly trpc: UseDeviceProxyTrpc;
+    readonly deviceId: number;
+    readonly features: readonly string[] | undefined;
+    /** Enable optimistic UI mode (default: true). Set to false to disable. */
+    readonly optimistic?: boolean;
+}
+export interface DeviceTypeControl {
+    /** Compact, state-aware controls rendered directly in a device-list row. */
+    readonly InlineControl: (p: DeviceControlProps) => ReactNode;
+    /** Full control surface rendered as a card in the device-detail hero area. */
+    readonly HeroCard: (p: DeviceControlProps) => ReactNode;
+}
+/**
+ * Exhaustive record over DeviceType. Omitting a member causes a
+ * TypeScript build error (same pattern as DEVICE_TYPE_ACTIONS).
+ */
+export declare const DEVICE_TYPE_CONTROL: Record<DeviceType, DeviceTypeControl>;
+/**
+ * Per-type FILL flag.
+ *
+ *   true  — range / choice / button controls (cover ▲■▼ triad, thermostat
+ *           setpoint stepper, media/control/button action buttons, alarm
+ *           segmented control). The child STRETCHES to the full column width.
+ *   false — readouts, tap-toggles, icon controls (lock), and dummy/placeholder
+ *           types. The child keeps its NATURAL width; where it sits in the
+ *           column (flush right vs centered) is decided by the caller via a
+ *           `ControlPlacement` — see `resolveControlAlign`.
+ *
+ * Dummy types (Camera, Hub, Generic, Weather, Vacuum, Container, and placeholder
+ * types Notifier/Script/Automation whose InlineControl renders "—") are `false` —
+ * the dash placeholder must not be stretched to the full column width. (AlarmPanel
+ * has a real segmented inline control and is `true`.) When a later task gives a
+ * remaining placeholder type a real stretchy inline control, flip its flag to true.
+ *
+ * Exhaustive over DeviceType — a missing member is a TypeScript build error.
+ */
+export declare const CONTROL_FILLS: Record<DeviceType, boolean>;
+/**
+ * Where a control sits, and whether the column carries the fixed `w-[140px]` box.
+ *   'right'  — natural-width content flush to the fixed column's right edge (card / minimal views).
+ *   'center' — natural-width content centered in the fixed column.
+ *   'table'  — the column DROPS its fixed width and sizes to its content (table view). Every type
+ *              resolves to FIT so the control takes its natural width and lays out in sequence with
+ *              the trailing trash + status dot, never overflowing a fixed box and colliding.
+ * FILL controls ignore 'right'/'center' (they always stretch to the fixed width); under 'table'
+ * a FILL control simply takes its natural width in the content-sized wrapper.
+ */
+export type ControlPlacement = 'right' | 'center' | 'table';
+/**
+ * Runtime-string-safe lookup: a device row's `type` crosses the wire
+ * as a plain string, so an unrecognised value resolves to null instead
+ * of indexing the registry with an unverified key.
+ */
+export declare function resolveDeviceControl(type: string): DeviceTypeControl | null;
+/**
+ * Runtime-string-safe alignment lookup for the fixed-width control column.
+ *
+ * A device's `type` crosses the wire as a plain string;
+ * `DEVICE_TYPE_VALUES.has(type)` narrows it to `DeviceType` before indexing
+ * `CONTROL_FILLS`, making the cast sound. The `'table'` placement is
+ * content-width for EVERY type (returns `FIT`), so a wide control never
+ * overflows a fixed box — the FILL flag is irrelevant there. For the fixed-box
+ * placements a FILL type always stretches (`FILL`) and a natural-width type is
+ * placed by the caller's `placement` — `'center'` → `CENTER`, `'right'` →
+ * `RIGHT` (card / minimal view). An unrecognised type falls back to
+ * natural-width placement.
+ */
+export declare function resolveControlAlign(type: string, placement: ControlPlacement): ControlAlign;

package/dist/composites/device-controls/cover-hero-card.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * CoverHeroCard — full control surface for the device-detail hero area.
+ *
+ * TWO VARIANTS based on whether the cover reports a position:
+ *
+ * With position (position !== null):
+ *  - Window graphic with slats descending from top to (100-position)%
+ *  - Visual (display-only) lever at the slat boundary with % label
+ *  - Open / Stop / Close buttons with state-aware highlight
+ *  - Interactive position range input (gated on CoverPositionable)
+ *  - Tilt range input (gated on CoverTilt)
+ *
+ * Without position (open/close-only, position === null):
+ *  - Window graphic showing state via clear pane (open) or full slats (closed)
+ *  - NO lever, NO % label; the value slot shows the cover STATE text (no %)
+ *  - Open / Stop / Close buttons with state-aware highlight
+ *
+ * Position support is detected via `CoverStatus.position !== null`.
+ * The interactive setPosition slider is gated on `DeviceFeature.CoverPositionable`.
+ *
+ * Follows the same `useDeviceCapability` pattern as CoverPanel / CoverInlineControl.
+ * Only hides when the device truly has no cover cap — a transient undefined slice
+ * renders a neutral "unknown" state with all buttons still mounted.
+ */
+export declare function CoverHeroCard({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/cover-inline.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+import { CoverState } from '@camstack/types';
+import { DeviceControlProps } from './control-registry';
+/** Button highlight variant for cover state-aware colouring. */
+export type CoverHighlightVariant = 'accent' | 'filled' | 'neutral';
+export interface CoverButtonHighlight {
+    readonly up: CoverHighlightVariant;
+    readonly stop: CoverHighlightVariant;
+    readonly down: CoverHighlightVariant;
+}
+/**
+ * Pure helper — maps a live CoverState (or undefined when no slice yet)
+ * to per-button highlight variants.
+ *
+ *   opening → up:accent  (transient/active upward motion)
+ *   closing → down:accent (transient/active downward motion)
+ *   open    → up:filled   (stable fully-open state)
+ *   closed  → down:filled (stable fully-closed state)
+ *   stopped / undefined → neutral (no active state)
+ */
+export declare function coverHighlight(state: CoverState | undefined): CoverButtonHighlight;
+/**
+ * CoverInlineControl — compact, state-aware cover controls for a
+ * device-list row. Renders ↑ ■ ↓ buttons + optional % open badge.
+ * Reuses `useDeviceCapability` exactly as `CoverPanel` does.
+ */
+export declare function CoverInlineControl({ trpc, deviceId, optimistic }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/cover-panel.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from 'react';
+import { ControlPanelProps } from './types';
+export declare function CoverPanel({ trpc, deviceId, features, layout }: ControlPanelProps): ReactNode;

package/dist/composites/device-controls/dummy-hero-card.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/** Inline placeholder: renders nothing (no-op row atom for types with no inline control). */
+export declare function DummyInline(_p: DeviceControlProps): ReactNode;
+/** Hero card placeholder: shows a muted "Controls coming soon" card for unimplemented types. */
+export declare function DummyHeroCard(_p: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/fan-hero-card.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * FanHeroCard — radial speed-dial hero for Fan devices.
+ *
+ * Renders:
+ *  - RadialGauge: draggable speed ArcKnob riding a 270° ring at the speed
+ *    fraction (drag snaps to the device's percentageStep), centered fan glyph +
+ *    percentage readout. The gauge is the sole speed control — no slider.
+ *  - Preset selector (centered) — ONLY when the device advertises
+ *    DeviceFeature.FanPreset AND the slice exposes a non-empty
+ *    `availablePresets`.
+ *  - TAP TOGGLE for on/off (Spec §3 — NOT a SlideToggle; slide is safety-only).
+ *  - Oscillate toggle button — ONLY when the device advertises
+ *    DeviceFeature.FanOscillating AND the slice exposes a non-null
+ *    `oscillating` value.
+ *
+ * Composes two caps: `switch` (on/off) + `fan-control` (speed / oscillate).
+ * Cap-gated on `switch` (always present on a Fan) — returns null without it.
+ */
+export declare function FanHeroCard({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/fan-panel.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from 'react';
+import { ControlPanelProps } from './types';
+export declare function FanPanel({ trpc, deviceId, features, layout, optimistic, }: ControlPanelProps): ReactNode;

package/dist/composites/device-controls/humidifier-control.d.ts

@@ -0,0 +1,37 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/** The `action` HA attribute drives the droplet / mist tint. */
+export type HumidifierAction = 'humidifying' | 'drying' | 'idle' | 'off';
+export interface HumidifierTint {
+    /** Tailwind class for the wash behind the droplet. */
+    readonly glow: string;
+    /** Tailwind text token driving the droplet via currentColor. */
+    readonly accent: string;
+    /** Whether to render the upward mist dashes (actively humidifying). */
+    readonly misting: boolean;
+}
+/**
+ * Pure helper — maps the device's on-state + HA `action` to a tint.
+ * Exhaustive over the known action strings; an unknown / null action
+ * falls back to on/off heuristics.
+ *
+ *   humidifying → primary (blue)
+ *   drying      → warning
+ *   idle / off  → muted
+ */
+export declare function humidifierTint(on: boolean, action: string | null): HumidifierTint;
+/**
+ * HumidifierInlineControl — compact on/off toggle + current→target readout
+ * for a device-list row. Must NOT blow out the row width.
+ */
+export declare function HumidifierInlineControl({ trpc, deviceId, optimistic, }: DeviceControlProps): ReactNode;
+/**
+ * HumidifierHeroCard — full control surface for the device-detail hero.
+ *
+ * Bespoke droplet + mist graphic + a large target-humidity readout +
+ * an on/off toggle + a target-humidity range slider (bounds from
+ * min/maxHumidity ?? 0..100) + a current-humidity readout + a mode
+ * `<select>` (only when modes are available). Gated on `available`.
+ * Only hides when the device truly has no humidifier cap.
+ */
+export declare function HumidifierHeroCard({ trpc, deviceId, optimistic }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/image-control.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * ImageInlineControl — compact thumbnail for a device-list row that expands
+ * into a floating preview on hover/focus (shared `HoverZoomImage`). Shows a
+ * muted ImageOff placeholder box when no url is available. Row-narrow.
+ *
+ * `DeviceControlProps` carries no device name, so the alt/caption is the
+ * generic 'Image'; the framed hero (ImageHeroCard) carries the real name.
+ */
+export declare function ImageInlineControl({ trpc, deviceId }: DeviceControlProps): ReactNode;
+export interface ImageHeroCardProps extends DeviceControlProps {
+    /** Optional device name for the image alt text. */
+    readonly deviceName?: string;
+}
+/**
+ * ImageHeroCard — read-only framed image for the device-detail hero.
+ *
+ * A still image in the cover-style framed box (rounded border,
+ * object-contain) when a url is present; a centered ImageOff + "No image"
+ * placeholder when null. Keeps the framed-box chrome for visual
+ * consistency with the other heroes.
+ */
+export declare function ImageHeroCard({ trpc, deviceId, deviceName }: ImageHeroCardProps): ReactNode;

package/dist/composites/device-controls/index.d.ts

@@ -0,0 +1,33 @@
+export { ControlColumn, ValueReadout, FILL, RIGHT, CENTER, type ControlAlign, Stepper, SlideToggle, ArcKnob, GripTrack, } from './atoms';
+export { RadialGauge, type RadialGaugeProps } from './radial-gauge';
+export { TapToggle, type TapToggleProps } from './tap-toggle';
+export { ButtonControl, ButtonHeroCard } from './button-control';
+export { CoverPanel } from './cover-panel';
+export { LockPanel } from './lock-panel';
+export { SwitchPanel } from './switch-panel';
+export { BrightnessPanel } from './brightness-panel';
+export { FanPanel } from './fan-panel';
+export { ClimatePanel, MODE_COLOR } from './climate-panel';
+export { MediaPlayerPanel, STATE_COLOR } from './media-player-panel';
+export { ControlPanel } from './control-panel';
+export { CONTROL_CAP_NAMES, type ControlCapName, type ControlPanelProps } from './types';
+export { PopoverRowAction } from './popover-row-action';
+export { SensorValueAtom, ROLE_DESCRIPTOR, type SensorDescriptor, type SensorValueAtomProps, } from './sensor-value-atom';
+export { DEVICE_TYPE_CONTROL, CONTROL_FILLS, resolveDeviceControl, resolveControlAlign, coverHighlight, type DeviceTypeControl, type DeviceControlProps, type ControlPlacement, } from './control-registry';
+export { OfflineBadge, type OfflineBadgeProps } from './offline-badge';
+export { CoverInlineControl, type CoverHighlightVariant, type CoverButtonHighlight, } from './cover-inline';
+export { CoverHeroCard } from './cover-hero-card';
+export { VacuumInlineControl, VacuumHeroCard, vacuumStateMeta, tankAlert, type VacuumStateMeta, type TankKind, type TankAlert, } from './vacuum-control';
+export { LawnMowerInlineControl, LawnMowerHeroCard, lawnMowerActivityMeta, type LawnMowerActivityMeta, } from './lawn-mower-control';
+export { ValveInlineControl, ValveHeroCard, valveStateMeta, type ValveStateMeta, } from './valve-control';
+export { HumidifierInlineControl, HumidifierHeroCard, humidifierTint, type HumidifierTint, type HumidifierAction, } from './humidifier-control';
+export { WaterHeaterInlineControl, WaterHeaterHeroCard, waterHeaterTint, waterHeaterPhase, type WaterHeaterTint, type WaterHeaterPhase, } from './water-heater-control';
+export { WeatherInlineControl, WeatherHeroCard, weatherTint, weatherConditionMeta, type WeatherTint, type WeatherConditionMeta, type WeatherGlyph, } from './weather-control';
+export { ImageInlineControl, ImageHeroCard, type ImageHeroCardProps, } from './image-control';
+export { DummyInline, DummyHeroCard } from './dummy-hero-card';
+export { SensorInlineControl } from './sensor-inline-control';
+export { SensorHeroCard } from './sensor-hero-card';
+export { SwitchInlineControl, SwitchHeroCard, LockInlineControl, LockHeroCard, LightInlineControl, LightHeroCard, FanInlineControl, FanHeroCard, ThermostatInlineControl, ThermostatHeroCard, MediaPlayerInlineControl, MediaPlayerHeroCard, AlarmPanelInlineControl, AlarmHeroCard, ControlInlineControl, ControlHeroCard, } from './panel-controls';
+export { resolvePrimaryChild, PRIORITY, type ChildRef } from './primary-child';
+export { resolveContainerPrimary, overrideEntityIdFromLink, containerChildToRef, childEntityId, type ContainerChild, } from './container-primary';
+export { ContainerPrimaryHero, type ContainerPrimaryHeroProps, type ContainerHeroChild, } from './container-primary-hero';

package/dist/composites/device-controls/lawn-mower-control.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { LawnMowerActivity } from '@camstack/types';
+import { DeviceControlProps } from './control-registry';
+export interface LawnMowerActivityMeta {
+    readonly label: string;
+    /** Tailwind text-colour token for the activity label. */
+    readonly tone: string;
+}
+/**
+ * Pure helper — maps a LawnMowerActivity (or undefined when no slice
+ * yet) to a human label + colour tone. Exhaustive switch: a new enum
+ * member fails the build.
+ */
+export declare function lawnMowerActivityMeta(activity: LawnMowerActivity | undefined): LawnMowerActivityMeta;
+/**
+ * LawnMowerInlineControl — compact, activity-aware mower controls for a
+ * device-list row. Mow / Pause / Dock + battery badge.
+ */
+export declare function LawnMowerInlineControl({ trpc, deviceId }: DeviceControlProps): ReactNode;
+/**
+ * LawnMowerHeroCard — full control surface for the device-detail hero
+ * area. Activity label + action buttons + battery readout.
+ */
+export declare function LawnMowerHeroCard({ trpc, deviceId }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/light-hero-card.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * LightHeroCard — radial dimmer hero for Light devices.
+ *
+ * Renders:
+ *  - RadialGauge: brightness ArcKnob riding a 270° ring at the level fraction,
+ *    centered bulb glyph + percentage readout.
+ *  - TAP TOGGLE for on/off (Spec §3 — NOT a SlideToggle; slide is safety-only).
+ *  - Colour-temperature GripTrack strip — ONLY when the device advertises
+ *    DeviceFeature.LightColorMired AND the `color` cap is bound.
+ *
+ * Composes three caps: `switch` (on/off), `brightness` (level), `color` (CT).
+ * Cap-gated on `switch` (always present on a Light) — returns null without it.
+ */
+export declare function LightHeroCard({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/lock-hero-card.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { DeviceControlProps } from './control-registry';
+/**
+ * LockHeroCard — padlock hero for lock devices.
+ *
+ * Renders:
+ *  - Padlock glyph: state-colored (locked=green, unlocked=amber, jammed=red)
+ *  - SlideToggle (safety gesture): thumb must be dragged past threshold to
+ *    confirm lock/unlock — a plain tap never triggers the action (Spec §3).
+ *  - Open (unlatch) button: rendered ONLY when device.features includes
+ *    DeviceFeature.LockOpen ('lock-open'). Absent otherwise.
+ *
+ * Cap-gated: returns null when the device has no lockControl cap.
+ */
+export declare function LockHeroCard({ trpc, deviceId, features, optimistic, }: DeviceControlProps): ReactNode;

package/dist/composites/device-controls/lock-panel.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from 'react';
+import { ControlPanelProps } from './types';
+export declare function LockPanel({ trpc, deviceId, layout, optimistic, features, }: ControlPanelProps): ReactNode;