julian
e0b9442acc
A Hikvision vehicle detection (eventType=VMD, targetType=vehicle) on a
camera bound to entry/exit now marks that lane "busy" and shows it as a
barrier light beside the scan input on the booth (green=free, red=busy).
Advisory only — it gates nothing (never blocks a ticket or opens a barrier).
- Parse eventState (active/inactive) from the Hik payload.
- LaneStatus tracker: a vehicle `active` event marks the camera's bound lane
busy + arms an auto-clear timer. This camera class sends no leave/`inactive`
signal, so "free" is timeout-driven (LANE_BUSY_TTL_MS, default 90s; the
camera re-fires `active` while a car sits there, refreshing the timer). A
"both"-direction camera marks both lanes.
- Push lane-status over the existing booth WS (+ in the hello snapshot);
live-store holds { entry, exit }; two BarrierLight icons render it.
- i18n booth.laneEntry/laneExit (sq + en).
Tests: lane-status.test.ts (7 — busy/free, TTL auto-clear, timer re-arm,
no re-emit while busy, both/exit direction, unknown device). server 120/120;
web + server build/lint green.
Claude-Session: https://claude.ai/code/session_01Xcm6ikLgGoCxxHrxtjkk5V
71 lines
2.9 KiB
TypeScript
71 lines
2.9 KiB
TypeScript
import { create } from "zustand";
|
|
import type { DeviceStatus, LedgerEvent, Occupancy } from "../api.js";
|
|
|
|
// CLIENT state for the live booth feed — deliberately small. Server data (the
|
|
// authoritative event list, occupancy totals) is owned by TanStack Query; this
|
|
// store holds only what Query shouldn't: the WS connection status, the latest
|
|
// pushed occupancy snapshot, and a rolling in-memory tail of recent events for the
|
|
// live ticker. Anything durable is re-fetched via Query. See lib/query.ts.
|
|
|
|
/** Connection state of the booth WebSocket, for a status indicator in the UI. */
|
|
export type WsStatus = "connecting" | "open" | "closed";
|
|
|
|
/** Per-lane busy/free from camera vehicle detection (advisory barrier lights). */
|
|
export interface LaneStatus {
|
|
entry: boolean; // true = busy
|
|
exit: boolean; // true = busy
|
|
}
|
|
|
|
/** Cap the in-memory live feed so a long-running booth session can't grow it
|
|
* unbounded — the full history is always available via the /api/events query. */
|
|
const MAX_FEED = 200;
|
|
|
|
interface LiveState {
|
|
status: WsStatus;
|
|
/** Most recent occupancy pushed by the server (rides on every ledger event). */
|
|
occupancy: Occupancy | null;
|
|
/** Newest-first tail of recently pushed ledger events (for the live ticker). */
|
|
feed: LedgerEvent[];
|
|
/** Live device status keyed by device id (for the footer): set from the WS
|
|
* hello snapshot, then upserted per device on each device-status push. */
|
|
devices: Record<string, DeviceStatus>;
|
|
/** Per-lane busy/free (camera vehicle detection). Null until the first WS hello. */
|
|
lanes: LaneStatus | null;
|
|
setStatus: (s: WsStatus) => void;
|
|
setOccupancy: (o: Occupancy) => void;
|
|
pushEvent: (e: LedgerEvent) => void;
|
|
/** Replace the whole device-status set (WS hello / reconnect snapshot). */
|
|
setDevices: (list: DeviceStatus[]) => void;
|
|
/** Upsert one device's status (a device-status push). */
|
|
upsertDevice: (d: DeviceStatus) => void;
|
|
/** Set lane busy/free (WS hello + each lane-status push). */
|
|
setLanes: (l: LaneStatus) => void;
|
|
reset: () => void;
|
|
}
|
|
|
|
/** Index a device-status list by device id. */
|
|
function byId(list: DeviceStatus[]): Record<string, DeviceStatus> {
|
|
const m: Record<string, DeviceStatus> = {};
|
|
for (const d of list) m[d.deviceId] = d;
|
|
return m;
|
|
}
|
|
|
|
export const useLiveStore = create<LiveState>((set) => ({
|
|
status: "connecting",
|
|
occupancy: null,
|
|
feed: [],
|
|
devices: {},
|
|
lanes: null,
|
|
setStatus: (status) => set({ status }),
|
|
setOccupancy: (occupancy) => set({ occupancy }),
|
|
pushEvent: (e) =>
|
|
set((s) => ({
|
|
// Newest first; de-dupe by id (a reconnect can replay) and cap the length.
|
|
feed: s.feed.some((x) => x.id === e.id) ? s.feed : [e, ...s.feed].slice(0, MAX_FEED),
|
|
})),
|
|
setDevices: (list) => set({ devices: byId(list) }),
|
|
upsertDevice: (d) => set((s) => ({ devices: { ...s.devices, [d.deviceId]: d } })),
|
|
setLanes: (lanes) => set({ lanes }),
|
|
reset: () => set({ status: "connecting", occupancy: null, feed: [], devices: {}, lanes: null }),
|
|
}));
|