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

package/dist/src/workspace/reports/chart/build.d.ts

@@ -0,0 +1,208 @@
+import type { ChartParameterSetup, ReportParameterSetup } from "@overvis/hmi-shared/report";
+import type { ReportCachePoint } from "./demand.js";
+import { type ReportColorPalette } from "./colors.js";
+export interface ChartBuiltSeries {
+    parameterId: string;
+    label: string;
+    /** Display-scaled y values aligned to `xs` (null = gap). */
+    ys: (number | null)[];
+    stroke: string;
+    fill: string | undefined;
+    paths: "line" | "bars" | "points" | "state" | "none";
+    spanGaps: boolean;
+    stackGroup: "fills" | "bars" | null;
+    opacity: number;
+    scaleMultiplier: number;
+    scaleShift: number;
+    decimalPlaces: number;
+    /** Integer/string change markers (vertical lines) in display space. */
+    changeMarkers: {
+        time: number;
+        color: string;
+        label: string;
+    }[];
+    /** Full-height state bands for integer filled-areas (valueColors), painted behind series. */
+    fillSpans: {
+        from: number;
+        to: number;
+        color: string;
+    }[];
+    /** Zone bands in display y (numeric). */
+    zoneBands: {
+        y0: number;
+        y1: number;
+        color: string;
+    }[];
+    /** Min/max extrema overlays (also merged into polyline X). */
+    extremaMarkers: {
+        time: number;
+        value: number;
+        kind: "min" | "max";
+    }[];
+    showAs: string;
+    seriesType: ChartParameterSetup["type"];
+}
+declare function toNumber(value: number | string): number | null;
+declare function applyScale(value: number, multiplier: number, shift: number): number;
+declare function invertScale(display: number, multiplier: number, shift: number): number;
+export { invertScale, applyScale, toNumber };
+/** A numeric line breaks only when the measured missing span exceeds its authored threshold. */
+export declare function shouldBreakChartGap(gapMs: number, gapThresholdMs: number): boolean;
+/**
+ * Midpoint time for segments slot `slot` in 1..N.
+ * Slots 1..N-1 are half-open width w; slot N ends at `to`.
+ */
+export declare function segmentSlotMidpoint(from: number, to: number, n: number, slot: number): number;
+/**
+ * Where the `null` that breaks a line goes. Right after the last sample, so held (stacked)
+ * series stop at the sample instead of running flat to the middle of the gap.
+ */
+export declare function gapBreakTime(prevTime: number, nextTime: number): number;
+/**
+ * Build dense display series for a numeric chart parameter with gap rules.
+ *
+ * Segment API slots: 0 = pre-segment (as-of at `from`), 1..N = in-window.
+ * `paintSegmentCount` is this chart's N (gap geometry); `segmentCount` is the
+ * cached fetch N. When they differ, samples are re-bucketed by time into paint slots.
+ * Sparse→window clip uses source **slot index** gaps, not time-distance > w.
+ * Short-segment path: break when skipped-slot width > `smallestGapSizeMs`.
+ */
+export declare function buildNumericSeriesValues(options: {
+    points: ReportCachePoint[];
+    segmentCount: number;
+    from: number;
+    to: number;
+    scaleMultiplier: number;
+    scaleShift: number;
+    smallestGapSizeMs: number;
+    /** When painting from sparse into HP window, clip to [from,to]. */
+    clipToWindow: boolean;
+    /** Sparse full extent — required for correct clip geometry. */
+    sourceFrom?: number;
+    sourceTo?: number;
+    /** This chart's N for gap/slot mapping (defaults to `segmentCount`). */
+    paintSegmentCount?: number;
+}): {
+    xs: number[];
+    ys: (number | null)[];
+};
+/** Insert extrema samples onto the polyline (sorted by time). */
+export declare function mergeExtremaIntoSeries(xs: number[], ys: (number | null)[], extrema: {
+    time: number;
+    value: number;
+}[]): {
+    xs: number[];
+    ys: (number | null)[];
+};
+/** Native min/max for the legend; scaled in-window markers for the plot. */
+export declare function chartExtremaDisplay(options: {
+    min: {
+        time: number;
+        value: number | string;
+    } | null | undefined;
+    max: {
+        time: number;
+        value: number | string;
+    } | null | undefined;
+    from: number;
+    to: number;
+    scaleMultiplier: number;
+    scaleShift: number;
+    enabled: boolean;
+}): {
+    markers: {
+        time: number;
+        value: number;
+        kind: "min" | "max";
+    }[];
+    nativeMin: number | null;
+    nativeMax: number | null;
+};
+/**
+ * Keep HP samples inside `[hpFrom, hpTo]`; fill the rest from sparse (nav) samples.
+ * Lets zoom-out reveal low-density data without dropping the loaded dense slice.
+ */
+export declare function mergeSparseAroundHp(sparseXs: number[], sparseYs: (number | null)[], hpXs: number[], hpYs: (number | null)[], hpFrom: number, hpTo: number): {
+    xs: number[];
+    ys: (number | null)[];
+};
+/**
+ * Discrete series counterpart of `mergeSparseAroundHp`: inside the high-precision window the
+ * fine points win (including their as-of point), the sparse full-range points fill the rest.
+ */
+export declare function mergeSparsePointsAroundHp(sparsePoints: readonly ReportCachePoint[], hpPoints: readonly ReportCachePoint[], hpFrom: number, hpTo: number): ReportCachePoint[];
+export declare function colorForIntegerValue(snapshot: ReportParameterSetup, value: number, opacity: number, palette?: ReportColorPalette): string;
+/**
+ * Integer filled-areas: hold value until next change (gapless states).
+ * Returns the held display series (tooltips) + valueColors state bands + change markers.
+ */
+export declare function buildIntegerFilledAreas(options: {
+    points: ReportCachePoint[];
+    from: number;
+    to: number;
+    snapshot: ReportParameterSetup;
+    opacity: number;
+    formatIntegerLabel?: (value: number, repr: string | null | undefined) => string;
+    palette?: ReportColorPalette;
+}): {
+    xs: number[];
+    ys: (number | null)[];
+    reprs: (string | null)[];
+    changeMarkers: ChartBuiltSeries["changeMarkers"];
+    fillSpans: ChartBuiltSeries["fillSpans"];
+};
+export declare function buildVerticalChangeMarkers(options: {
+    points: ReportCachePoint[];
+    from: number;
+    to: number;
+    snapshot: ReportParameterSetup;
+    opacity: number;
+    formatIntegerLabel?: (value: number, repr: string | null | undefined) => string;
+    palette?: ReportColorPalette;
+}): ChartBuiltSeries["changeMarkers"];
+export declare function buildZoneBands(snapshot: ReportParameterSetup, scaleMultiplier: number, scaleShift: number, palette?: ReportColorPalette): ChartBuiltSeries["zoneBands"];
+/**
+ * Last `reprs[i]` whose `xs[i] <= timeMs` (`xs` sorted ascending, milliseconds).
+ * Used for chart tooltips on a shared-X cursor (index is not series-local).
+ */
+export declare function reprAtTime(xs: readonly number[], reprs: readonly (string | null | undefined)[], timeMs: number): string | null;
+/**
+ * Align multiple series onto a shared X timeline (union of sample times).
+ *
+ * `hold: true` (stacked groups, integer state series): last explicit value,
+ * including own-gap `null`, at foreign timestamps; leading null.
+ * Otherwise interpolate between surrounding explicit numeric samples; null
+ * across own gaps and outside the series' own time span.
+ */
+export declare function alignSeriesToSharedXs(seriesList: {
+    xs: number[];
+    ys: (number | null)[];
+    hold?: boolean;
+}[]): {
+    xs: number[];
+    aligned: (number | null)[][];
+};
+/**
+ * Stack ys bottom→top within a group (null stays null).
+ */
+export declare function stackAlignedYs(aligned: (number | null)[][]): (number | null)[][];
+export declare function strokeFillForParam(snapshot: ReportParameterSetup, opacity: number, showAs: string, palette?: ReportColorPalette): {
+    stroke: string;
+    fill: string | undefined;
+};
+export declare function shouldShowChartNavStrip(options: {
+    navStrip: "none" | "frozen" | "movable";
+    sparseExtent: {
+        from: number;
+        to: number;
+    } | null;
+    sparseExtentLoading: boolean;
+}): boolean;
+export declare function chartNavBrushAllowed(options: {
+    navStrip: "none" | "frozen" | "movable";
+    immutableTimeRange: boolean;
+}): boolean;
+export declare function chartPlotPanZoomAllowed(options: {
+    chartDisplay: "frozen" | "movable";
+    immutableTimeRange: boolean;
+}): boolean;

package/dist/src/workspace/reports/chart/caches.d.ts

@@ -0,0 +1,57 @@
+import { type ReadingsMinMaxOutput, type ReadingsParameterRef } from "@overvis/hmi-shared/parameter";
+import type { ReportCacheEnv, ReportCacheSpec } from "../data/report-caches.js";
+import { type DemandCacheMap } from "../demand-cache.js";
+import { type ReportChartDemand, type ReportHighPrecisionCache, type ReportSeriesCacheEntry, type ReportSparseCache } from "./demand.js";
+export interface ReportChartCaches {
+    sparseCache: ReportSparseCache;
+    highPrecisionCache: ReportHighPrecisionCache;
+}
+export interface ReportChartCacheEnv extends ReportCacheEnv {
+    /** Drop live overlay points a high-precision fetch now covers (last sample per series key). */
+    trimOverlayToHp: (hpToByKey: ReadonlyMap<string, number>) => void;
+}
+/** A demanded series over one window at one segment count. */
+export interface ReportSeriesNeed extends ReadingsParameterRef {
+    key: string;
+    segmentCount: number;
+    from: number;
+    to: number;
+}
+export interface ReportHighPrecisionNeed extends ReportSeriesNeed {
+    /** Some mounted chart shows per-parameter min/max. */
+    withMinMax: boolean;
+}
+type SeriesCache = DemandCacheMap<ReportSeriesCacheEntry>;
+/**
+ * Chart series: sparse over the frozen data extent (nav strip) and high precision over the
+ * high-precision window, with per-parameter min/max when a chart shows it.
+ */
+export declare const reportChartCaches: ReportCacheSpec<ReportChartDemand, ReportChartCaches, ReportChartCacheEnv>;
+/** Sparse series of the demanded parameters over the frozen data extent (nav strip). */
+export declare function collectSparseNeeds(demands: ReadonlyMap<string, ReportChartDemand>, extent: {
+    from: number;
+    to: number;
+}): ReportSeriesNeed[];
+/** High-precision series of the demanded parameters over the (rounded) high-precision window. */
+export declare function collectHighPrecisionNeeds(demands: ReadonlyMap<string, ReportChartDemand>, window: {
+    from: number;
+    to: number;
+}): ReportHighPrecisionNeed[];
+/**
+ * Sparse is refetched unless loaded at an adequate segment count. A `loading` entry belongs to a
+ * superseded (aborted) run.
+ */
+export declare function sparseEntryNeedsFetch(entry: ReportSeriesCacheEntry | undefined, need: ReportSeriesNeed): boolean;
+/** High precision needs segments unless loaded for this window at an adequate segment count. */
+export declare function hpEntryNeedsSegments(entry: ReportSeriesCacheEntry | undefined, need: ReportHighPrecisionNeed): boolean;
+/** Loaded numeric high precision that still needs min/max (no segment reload). */
+export declare function hpEntryNeedsMinMaxOnly(entry: ReportSeriesCacheEntry | undefined, need: ReportHighPrecisionNeed): boolean;
+export declare function hpEntryNeedsFetch(entry: ReportSeriesCacheEntry | undefined, need: ReportHighPrecisionNeed): boolean;
+type MinMaxResult = Pick<ReportSeriesCacheEntry, "minMaxFetched" | "minMaxError"> & {
+    minMax: ReadingsMinMaxOutput | null;
+};
+/** Min/max into loaded entries that still cover the window it was fetched for. */
+export declare function patchMinMaxIntoCache(prev: SeriesCache, needs: readonly ReportSeriesNeed[], minMax: MinMaxResult): SeriesCache;
+/** Chunk so `(N+1)×chunk ≤ 50_000` and params ≤ 100 (schema maxItems). */
+export declare function chunkReadingsParams(parameters: ReadingsParameterRef[], segmentCount: number): ReadingsParameterRef[][];
+export {};

package/dist/src/workspace/reports/chart/colors.d.ts

@@ -0,0 +1,17 @@
+import type { ReportColor } from "@overvis/hmi-shared/report";
+/** Live widgets read CSS vars; HTML/PNG snapshots always use light hex. */
+export type ReportColorPalette = "theme" | "light";
+/** Light-mode fill hex matching workspace-ui `--report-color-*-fill` (canvas needs concrete colors). */
+export declare const REPORT_COLOR_FILL_HEX: Record<ReportColor, string>;
+export declare const REPORT_COLOR_BORDER_HEX: Record<ReportColor, string>;
+export declare const REPORT_COLOR_TEXT_HEX: Record<ReportColor, string>;
+/** Theme-aware fill (CSS var at draw time, hex fallback). */
+export declare function reportColorFillCss(color: ReportColor): string;
+/** Theme-aware border (CSS var at draw time, hex fallback). */
+export declare function reportColorBorderCss(color: ReportColor): string;
+export declare function reportColorFillHex(color: ReportColor): string;
+export declare function reportColorBorderHex(color: ReportColor): string;
+export declare function reportColorTextHex(color: ReportColor): string;
+export declare function reportColorFill(color: ReportColor, palette?: ReportColorPalette): string;
+export declare function reportColorBorder(color: ReportColor, palette?: ReportColorPalette): string;
+export declare function withOpacity(color: string, opacity: number): string;

package/dist/src/workspace/reports/chart/comment-gutter.d.ts

@@ -0,0 +1,44 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import { type ReportColor, type ReportComment } from "@overvis/hmi-shared/report";
+export interface ChartCommentStripe {
+    id: string;
+    from: number;
+    to: number;
+    color: ReportColor;
+    author: string;
+    content: string;
+}
+export declare function plotCommentStripes(options: {
+    locale: AppLocale;
+    comments: readonly ReportComment[];
+    from: number;
+    to: number;
+    visibleParameterIds: ReadonlySet<string>;
+    parametersById: ReadonlyMap<string, {
+        defaultColor: ReportColor;
+    }>;
+    authorsById: ReadonlyMap<string, string>;
+}): ChartCommentStripe[];
+export declare function commentStripeLayout(commentFrom: number, commentTo: number, windowFrom: number, windowTo: number, plotWidth: number): {
+    left: number;
+    width: number;
+    clipFrom: number;
+    clipTo: number;
+} | null;
+export interface PackedCommentStripe {
+    stripe: ChartCommentStripe;
+    left: number;
+    width: number;
+    lane: number;
+}
+export declare function packCommentStripes(stripes: readonly ChartCommentStripe[], windowFrom: number, windowTo: number, plotWidth: number): {
+    items: PackedCommentStripe[];
+    laneCount: number;
+};
+export declare function ChartCommentGutter({ stripes, from, to, plotLeft, plotWidth, }: {
+    stripes: ChartCommentStripe[];
+    from: number;
+    to: number;
+    plotLeft: number;
+    plotWidth: number;
+}): import("react").JSX.Element;

package/dist/src/workspace/reports/chart/demand.d.ts

@@ -0,0 +1,50 @@
+import type { ReadingsParameterRef } from "@overvis/hmi-shared/parameter";
+/** Cache key for sparse/HP series maps. */
+export declare function reportCacheKey(parameterId: string, sourceValueType: string): string;
+export interface ReportChartDemand {
+    /** Parameters this mounted chart needs from readings. */
+    parameters: ReadingsParameterRef[];
+    /** Chart `fullRangePointsForNavigationPerParameter`. */
+    sparseMaxPoints: number;
+    /** Chart `maximumPointsOnScreenPerParameter`. */
+    hpMaxPoints: number;
+    minimumPrecisionMs: number;
+    showMinMaxPerParameter: boolean;
+    /** Chart `realtimeUpdate` — listen-only overlay for this widget. */
+    realtimeUpdate: boolean;
+}
+export interface ReportCachePoint {
+    index: number;
+    time: number;
+    value: number | string;
+    repr?: string | null;
+}
+export interface ReportSeriesCacheEntry {
+    parameterId: string;
+    sourceValueType: string;
+    points: ReportCachePoint[];
+    segmentCount: number;
+    status: "idle" | "loading" | "ready" | "error";
+    /** Stable `readings_*` code or null. */
+    error: string | null;
+    /** HP window this entry covers (sparse omits). */
+    windowFrom: number | null;
+    windowTo: number | null;
+    min: {
+        time: number;
+        value: number | string;
+    } | null;
+    max: {
+        time: number;
+        value: number | string;
+    } | null;
+    /** True after a minMax request was applied (even if extrema are null). */
+    minMaxFetched: boolean;
+    /** readings_* code when minMax was required and failed. */
+    minMaxError: string | null;
+}
+export type ReportSparseCache = Map<string, ReportSeriesCacheEntry>;
+export type ReportHighPrecisionCache = Map<string, ReportSeriesCacheEntry>;
+export declare function emptySeriesCacheEntry(parameterId: string, sourceValueType: string): ReportSeriesCacheEntry;
+export declare function serializeReportChartDemand(demand: ReportChartDemand): string;
+export declare function aggregateDemandedParams(demands: ReadonlyMap<string, ReportChartDemand>): ReadingsParameterRef[];

package/dist/src/workspace/reports/chart/paint.d.ts

@@ -0,0 +1,17 @@
+import uPlot from "uplot";
+import type { PreparedSeries } from "./payload.js";
+export declare function clipToPlotBBox(ctx: CanvasRenderingContext2D, u: uPlot): void;
+/**
+ * Behind the series (drawClear): integer state bands, then numeric zone bands. Zones belong
+ * to one series, so with several numeric series sharing the axis they are faded unless one
+ * is focused.
+ */
+export declare function paintChartBackground(u: uPlot, series: readonly PreparedSeries[], focusedParameterId: string | null): void;
+/** How many change markers sit in the current X window (seconds). */
+export declare function countChangeMarkersInWindow(markers: readonly {
+    time: number;
+}[], fromSec: number, toSec: number): number;
+/** Full strength while markers are sparse; fades with density so dense event runs stay legible. */
+export declare function changeMarkerAlpha(markerCount: number, plotWidthPx: number): number;
+/** Above the series (draw): integer/string change markers and numeric min/max dots. */
+export declare function paintChartOverlays(u: uPlot, series: readonly PreparedSeries[]): void;

package/dist/src/workspace/reports/chart/pan-zoom.d.ts

@@ -0,0 +1,19 @@
+/** Floor so wheel-zoom cannot collapse the window. */
+export declare const CHART_MIN_WINDOW_MS = 1000;
+export declare const CHART_PAN_THRESHOLD_PX = 5;
+export declare const CHART_WHEEL_SENSITIVITY = 0.0015;
+export declare const CHART_WHEEL_COMMIT_MS = 150;
+/** Next `[from, to]` after X zoom (around `anchor`) and/or pan. Not bounded by data extent. */
+export declare function applyChartPanZoom(args: {
+    fromMs: number;
+    toMs: number;
+    zoom: number;
+    anchor: number;
+    panMs: number;
+    minDurationMs?: number;
+}): {
+    from: number;
+    to: number;
+};
+/** `deltaY < 0` (wheel up / pinch out) → zoom in (`factor < 1`). */
+export declare function chartWheelZoomFactor(deltaY: number): number;

package/dist/src/workspace/reports/chart/payload.d.ts

@@ -0,0 +1,57 @@
+import uPlot from "uplot";
+import type { ReportColor } from "@overvis/hmi-shared/report";
+export interface PreparedSeries {
+    parameterId: string;
+    label: string;
+    defaultColor: ReportColor;
+    visible: boolean;
+    xs: number[];
+    ys: (number | null)[];
+    stroke: string;
+    fill: string | undefined;
+    showAs: string;
+    seriesType: "numeric" | "integer" | "string";
+    /** `state`: held integer series that joins the shared X (tooltips) but paints as bands only. */
+    paths: "line" | "bars" | "points" | "state" | "none";
+    stackGroup: "fills" | "bars" | null;
+    scaleMultiplier: number;
+    scaleShift: number;
+    decimalPlaces: number;
+    changeMarkers: {
+        time: number;
+        color: string;
+        label: string;
+    }[];
+    /** Full-height state bands (integer filled-areas), painted behind the series. */
+    fillSpans: {
+        from: number;
+        to: number;
+        color: string;
+    }[];
+    zoneBands: {
+        y0: number;
+        y1: number;
+        color: string;
+    }[];
+    extremaMarkers: {
+        time: number;
+        value: number;
+        kind: "min" | "max";
+    }[];
+    nativeMin: number | null;
+    nativeMax: number | null;
+    /** Resolved integer labels aligned to `xs` (tooltip); empty for numeric. */
+    reprs: (string | null)[];
+}
+export declare function buildUplotPayload(series: PreparedSeries[], from: number, to: number): {
+    data: uPlot.AlignedData;
+    seriesOpts: uPlot.Series[];
+    bands: uPlot.Band[];
+    drawHooks: PreparedSeries[];
+    stackedMeta: {
+        parameterId: string;
+        indexInData: number;
+    }[];
+    drawable: PreparedSeries[];
+    ownAligned: (number | null)[][];
+};

package/dist/src/workspace/reports/chart/plot-interactions.d.ts

@@ -0,0 +1,13 @@
+import uPlot from "uplot";
+import type { RefObject } from "react";
+import type { buildUplotPayload } from "./payload.js";
+/** Pan, wheel zoom, and click-to-focus on the plot overlay; returns the listener cleanup. */
+export declare function attachChartPlotInteractions(plot: uPlot, input: {
+    tooltipRef: RefObject<HTMLDivElement | null>;
+    payloadRef: RefObject<ReturnType<typeof buildUplotPayload> | null>;
+    interactingRef: RefObject<boolean>;
+    onPanZoomRef: RefObject<((from: number, to: number) => void) | undefined>;
+    panZoomEnabled: boolean;
+    focusAxisOnSeries: boolean;
+    onFocusParameter: (parameterId: string | null) => void;
+}): () => void;

package/dist/src/workspace/reports/chart/plot-tooltip.d.ts

@@ -0,0 +1,10 @@
+import uPlot from "uplot";
+import type { RefObject } from "react";
+import type { buildUplotPayload } from "./payload.js";
+/** uPlot `setCursor` hook body: fills and places the hover tooltip for the cursor index. */
+export declare function updateChartPlotTooltip(u: uPlot, input: {
+    tooltipRef: RefObject<HTMLDivElement | null>;
+    wrapRef: RefObject<HTMLDivElement | null>;
+    payloadRef: RefObject<ReturnType<typeof buildUplotPayload> | null>;
+    timeZone: string;
+}): void;

package/dist/src/workspace/reports/chart/plot.d.ts

@@ -0,0 +1,29 @@
+import { type ChartCommentStripe } from "./comment-gutter.js";
+import { type PreparedSeries } from "./payload.js";
+declare function ChartPlotInner({ series, from, to, timeZone, height, interactive, showTooltip, focusAxisOnSeries, focusedParameterId, onFocusParameter, onBrushSelect, onPanZoom, windowOverlay, showXTickLabels, className, commentStripes, dataReportPlot, }: {
+    series: PreparedSeries[];
+    from: number;
+    to: number;
+    timeZone: string;
+    height: number;
+    interactive: boolean;
+    showTooltip: boolean;
+    focusAxisOnSeries: boolean;
+    focusedParameterId: string | null;
+    onFocusParameter: (parameterId: string | null) => void;
+    onBrushSelect?: (from: number, to: number) => void;
+    /** Main-plot click-drag pan + wheel zoom → shared time window. */
+    onPanZoom?: (from: number, to: number) => void;
+    /** Highlight [windowFrom, windowTo] on a full-extent nav strip. */
+    windowOverlay?: {
+        from: number;
+        to: number;
+    };
+    /** When false (nav strip), omit x-axis date labels. */
+    showXTickLabels?: boolean;
+    className?: string;
+    commentStripes?: ChartCommentStripe[];
+    dataReportPlot?: string;
+}): import("react").JSX.Element;
+export declare const ChartPlot: import("react").MemoExoticComponent<typeof ChartPlotInner>;
+export {};

package/dist/src/workspace/reports/chart/realtime.d.ts

@@ -0,0 +1,96 @@
+import type { ReadingsRealtimeEvent } from "@overvis/hmi-shared/parameter";
+import type { ReportDefaultTimeRange } from "@overvis/hmi-shared/report";
+import { type ReportCachePoint, type ReportChartDemand } from "./demand.js";
+export declare const REPORT_REALTIME_OVERLAY_MAX_POINTS = 1000;
+export declare const FOLLOW_LIVE_RESTORE_SLACK_MS = 5000;
+export declare const FOLLOW_LIVE_HP_REFRESH_MS = 30000;
+export declare const FOLLOW_LIVE_PERSIST_MS = 1000;
+export interface ReportRealtimePoint {
+    time: number;
+    value: number | string;
+    repr?: string | null;
+}
+export type ReportRealtimeOverlay = Map<string, ReportRealtimePoint[]>;
+export declare function coerceRealtimeValue(value: number | string, sourceValueType: string): number | string | null;
+export declare function ingestRealtimePoint(prev: ReportRealtimeOverlay, key: string, event: Pick<ReadingsRealtimeEvent, "time" | "value" | "repr">, sourceValueType: string, maxPoints?: number): {
+    overlay: ReportRealtimeOverlay;
+    accepted: boolean;
+    atCap: boolean;
+};
+export declare function trimOverlayAfterHp(prev: ReportRealtimeOverlay, hpWindowToByKey: ReadonlyMap<string, number>): ReportRealtimeOverlay;
+export declare function realtimeSubscribeParameterIds(demands: Iterable<ReportChartDemand>): string[];
+export declare function defaultTimeRangeEndsAtNow(type: ReportDefaultTimeRange["type"]): boolean;
+export declare function shouldFollowLive(options: {
+    defaultTimeRangeType: ReportDefaultTimeRange["type"];
+    immutableTimeRange: boolean;
+    storedTo: number | null;
+    nowMs: number;
+    usingStoredRange: boolean;
+}): boolean;
+export declare function overlayAtCap(overlay: ReportRealtimeOverlay, maxPoints?: number): boolean;
+export declare function overlayPointsInWindow(points: readonly ReportRealtimePoint[], from: number, to: number, afterTime: number): ReportRealtimePoint[];
+export declare function overlayAsCachePoints(points: readonly ReportRealtimePoint[]): ReportCachePoint[];
+export declare function lastPointTime(points: readonly {
+    time: number;
+}[]): number | null;
+export declare function mergeWindowExtrema(hpMin: {
+    time: number;
+    value: number | string;
+} | null, hpMax: {
+    time: number;
+    value: number | string;
+} | null, overlay: readonly ReportRealtimePoint[], from: number, to: number): {
+    min: {
+        time: number;
+        value: number;
+    } | null;
+    max: {
+        time: number;
+        value: number;
+    } | null;
+};
+export declare function appendRealtimeOverlayTail(options: {
+    xs: number[];
+    ys: (number | null)[];
+    overlay: readonly ReportRealtimePoint[];
+    from: number;
+    to: number;
+    afterTime: number;
+    scaleMultiplier: number;
+    scaleShift: number;
+    gapThresholdMs: number;
+}): {
+    xs: number[];
+    ys: (number | null)[];
+};
+export declare function shouldExtendFollowLiveTo(options: {
+    accepted: boolean;
+    followLive: boolean;
+    eventTime: number;
+    currentTo: number;
+}): boolean;
+export declare function shouldTrimOverlayAfterHpFetch(wantMinMax: boolean, minMaxFetched: boolean): boolean;
+/** Clip int/str builders to the view when realtime; otherwise keep frozen sparse extent. */
+export declare function discretePaintWindow(options: {
+    applyRealtime: boolean;
+    viewFrom: number;
+    viewTo: number;
+    sparseFrom: number | null | undefined;
+    sparseTo: number | null | undefined;
+}): {
+    from: number;
+    to: number;
+};
+/** Last returned HP sample per series — omit keys with no points so overlay is not trimmed. */
+export declare function overlayTrimTimesFromHpSeries(parameters: readonly {
+    parameterId: string;
+    sourceValueType: string;
+}[], data: {
+    series: readonly {
+        parameterId: string;
+        points: readonly {
+            time: number;
+        }[];
+    }[];
+}): Map<string, number>;
+export declare function headerTimeRangeTextUnchanged(fromText: string, toText: string, fromCommitted: string, toCommitted: string): boolean;

package/dist/src/workspace/reports/chart/representation.d.ts

@@ -0,0 +1,40 @@
+import { type ReactNode } from "react";
+import { type ChartSetup } from "@overvis/hmi-shared/report";
+import type { PreparedSeries } from "./payload.js";
+import { type ReportChartCacheContextValue, type ReportSessionContextValue } from "../data/context.js";
+import { type ReportRealtimeOverlay } from "./realtime.js";
+export interface ChartRepresentationProps {
+    representationKey: string;
+    setup: ChartSetup;
+    className?: string;
+}
+/** Build drawable series. `useHighPrecision: false` keeps sparse-only (nav strip). */
+export declare function prepareChartSeries(options: {
+    setup: ChartSetup;
+    parametersById: ReportSessionContextValue["parametersById"];
+    visibleParameterIds: ReadonlySet<string>;
+    from: number;
+    to: number;
+    /** Main plot splices HP into the view; nav strip passes false (sparse-only). */
+    useHighPrecision: boolean;
+    sparseCache: ReportChartCacheContextValue["sparseCache"];
+    highPrecisionCache: ReportChartCacheContextValue["highPrecisionCache"];
+    sparseExtent: {
+        from: number;
+        to: number;
+    } | null;
+    paintSegmentCount: number;
+    liveOverlay: ReportRealtimeOverlay;
+    applyRealtime: boolean;
+    realtimeError: string | null;
+    palette?: "theme" | "light";
+    locale?: string;
+}): {
+    series: PreparedSeries[];
+    error: string | null;
+    loading: boolean;
+};
+/**
+ * Runtime chart representation (uPlot). Registers demand with ReportDataProvider.
+ */
+export declare function ChartRepresentation({ representationKey, setup, className, }: ChartRepresentationProps): ReactNode;