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

package/dist/src/workspace/reports/preset/submit.d.ts

@@ -0,0 +1,43 @@
+import type { ReportPresetSetupPayload } from "@overvis/hmi-shared/report";
+export type ReportPresetEditorMode = {
+    kind: "create";
+} | {
+    kind: "update";
+    presetId: string;
+} | {
+    kind: "promote";
+    presetId: string;
+};
+export declare function reportPresetEditorMode(input: {
+    presetId: string | undefined;
+    promoteTemporary: boolean;
+}): ReportPresetEditorMode;
+export declare function reportPresetEditDestination(input: {
+    isTemporary: boolean;
+    promoteTemporary: boolean;
+}): "editor" | "runtime";
+export type ReportPresetSubmitCall = {
+    procedure: "create";
+    input: {
+        workspaceId: string;
+    } & ReportPresetSetupPayload;
+} | {
+    procedure: "update";
+    input: {
+        id: string;
+        baseRevision?: number;
+    } & ReportPresetSetupPayload;
+} | {
+    procedure: "saveTemporary";
+    input: {
+        id: string;
+        baseRevision?: number;
+    } & ReportPresetSetupPayload;
+};
+export declare function reportPresetSubmitCall(input: {
+    mode: ReportPresetEditorMode;
+    workspaceId: string;
+    payload: ReportPresetSetupPayload;
+    /** The preset's revision the edit started from; sent with an update and a promotion. */
+    baseRevision?: number;
+}): ReportPresetSubmitCall;

package/dist/src/workspace/reports/quick-report.d.ts

@@ -0,0 +1,17 @@
+export type QuickReportActionState = {
+    kind: "ready";
+    parameterIds: string[];
+} | {
+    kind: "empty";
+} | {
+    kind: "over_limit";
+    limit: number;
+    count: number;
+} | {
+    kind: "pending";
+};
+export declare function quickReportActionState(input: {
+    parameterIds: readonly string[];
+    pending: boolean;
+    limit?: number;
+}): QuickReportActionState;

package/dist/src/workspace/reports/readings-client.d.ts

@@ -0,0 +1,23 @@
+import type { ReadingsAggregateInput, ReadingsAggregateOutput, ReadingsCadenceInput, ReadingsCadenceOutput, ReadingsChangePointsInput, ReadingsChangePointsOutput, ReadingsDaysInput, ReadingsDaysOutput, ReadingsMinMaxInput, ReadingsMinMaxOutput, ReadingsRawInput, ReadingsRawOutput, ReadingsSegmentsInput, ReadingsSegmentsOutput, ReadingsTimeExtentInput, ReadingsTimeExtentOutput } from "@overvis/hmi-shared/parameter";
+interface ReadingsQuery<I, O> {
+    query: (input: I, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<O>;
+}
+/** The `readings.*` queries report caches use (`trpc.useUtils().client.readings`). */
+export interface ReportReadingsClient {
+    cadence: ReadingsQuery<ReadingsCadenceInput, ReadingsCadenceOutput>;
+    days: ReadingsQuery<ReadingsDaysInput, ReadingsDaysOutput>;
+    aggregate: ReadingsQuery<ReadingsAggregateInput, ReadingsAggregateOutput>;
+    raw: ReadingsQuery<ReadingsRawInput, ReadingsRawOutput>;
+    changePoints: ReadingsQuery<ReadingsChangePointsInput, ReadingsChangePointsOutput>;
+    segments: ReadingsQuery<ReadingsSegmentsInput, ReadingsSegmentsOutput>;
+    minMax: ReadingsQuery<ReadingsMinMaxInput, ReadingsMinMaxOutput>;
+    timeExtent: ReadingsQuery<ReadingsTimeExtentInput, ReadingsTimeExtentOutput>;
+}
+/** A workspace and the `readings.*` queries a fetch uses. */
+export interface ReportReadingsEnv<K extends keyof ReportReadingsClient = keyof ReportReadingsClient> {
+    workspaceId: string;
+    readings: Pick<ReportReadingsClient, K>;
+}
+export {};

package/dist/src/workspace/reports/runtime-chrome.d.ts

@@ -0,0 +1,15 @@
+/** Runtime header chrome for a report page. Permanent vs temporary is a closed set. */
+export type ReportRuntimeChrome = {
+    kind: "permanent";
+    showEdit: boolean;
+    backTarget: "reports" | null;
+} | {
+    kind: "temporary";
+    showSave: boolean;
+    backTarget: "parameters" | null;
+};
+export declare function reportRuntimeChrome(input: {
+    isTemporary: boolean;
+    canWriteSetup: boolean;
+    showEditButton: boolean;
+}): ReportRuntimeChrome;

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

@@ -0,0 +1,47 @@
+import type { SankeySetup } from "@overvis/hmi-shared/report";
+export interface ReportSankeyDemandSlot {
+    parameterId: string;
+    sourceValueType: string;
+}
+export interface ReportSankeyDemand {
+    slots: ReportSankeyDemandSlot[];
+    valueAggregation: SankeySetup["valueAggregation"];
+}
+export type ReportSankeyEntryStatus = "idle" | "loading" | "ready" | "error";
+export interface ReportSankeyEntry {
+    value: number | null;
+    status: ReportSankeyEntryStatus;
+    error: string | null;
+}
+export type ReportSankeyCache = Map<string, ReportSankeyEntry>;
+export interface ReportSankeyNeed {
+    key: string;
+    parameterId: string;
+    sourceValueType: string;
+    aggregation: SankeySetup["valueAggregation"];
+    from: number;
+    to: number;
+}
+export declare function emptySankeyEntry(): ReportSankeyEntry;
+export declare function sankeyClosedTo(from: number, to: number, timeZone: string, nowMs?: number): number;
+/** Slack matching follow-live restore: a `to` this close to wall clock is a live window. */
+export declare const SANKEY_LIVE_PIN_SLACK_MS = 5000;
+export declare function sankeyWindowEndsAtNow(sessionTo: number, nowMs: number, slackMs?: number): boolean;
+/**
+ * Sticky live pin: update only when session `to` changes. Stale `to` after a minute
+ * without realtime still counts as follow-live so closed-minute refetch can run.
+ */
+export declare function nextSankeyLivePin(prevPinned: boolean, sessionTo: number, prevSessionTo: number, nowMs: number, slackMs?: number): boolean;
+/** Follow-live uses wall clock as `to`; historical windows keep session `to`. */
+export declare function sankeyEffectiveTo(sessionTo: number, nowMs: number, livePinned: boolean): number;
+export declare function sankeyCacheKey(parts: {
+    parameterId: string;
+    sourceValueType: string;
+    aggregation: string;
+    from: number;
+    closedTo: number;
+}): string;
+export declare function serializeReportSankeyDemand(demand: ReportSankeyDemand): string;
+export declare function collectSankeyNeeds(demands: ReadonlyMap<string, ReportSankeyDemand>, from: number, to: number, timeZone: string, nowMs?: number): ReportSankeyNeed[];
+export declare function sankeyEntryNeedsFetch(entry: ReportSankeyEntry | undefined): boolean;
+export declare function numericAggregateValue(value: number | string | null | undefined): number | null;

package/dist/src/workspace/reports/sankey/graph.d.ts

@@ -0,0 +1,28 @@
+export interface SankeyGraphLink {
+    fromNodeId: string;
+    toNodeId: string;
+    parameterId: string;
+}
+export declare function sankeyLinkTupleKey(fromNodeId: string, toNodeId: string, parameterId: string): string;
+export declare function sankeyHasLink(links: readonly SankeyGraphLink[], fromNodeId: string, toNodeId: string, parameterId: string): boolean;
+/** Nodes that can reach `target` (including `target`) on the current DAG. */
+export declare function sankeyNodesThatCanReach(links: readonly SankeyGraphLink[], target: string): Set<string>;
+/** Legal `to` ids for a new edge from `fromNodeId` (no self-loop, no cycle). */
+export declare function sankeyValidToNodeIds(nodeIds: readonly string[], links: readonly SankeyGraphLink[], fromNodeId: string): string[];
+export declare function sankeyHasCycle(nodeIds: readonly string[], links: readonly SankeyGraphLink[]): boolean;
+/**
+ * Legal `to` ids for an existing/new link with a fixed `parameterId`
+ * (DAG-safe and not a duplicate tuple against `links`).
+ */
+export declare function sankeyLegalToNodeIds(nodeIds: readonly string[], links: readonly SankeyGraphLink[], fromNodeId: string, parameterId: string): string[];
+/**
+ * `from` ids that still have at least one legal `to` for `parameterId`.
+ * Always includes `currentFromId` so a loaded cyclic/duplicate recipe can keep its from.
+ */
+export declare function sankeyLegalFromNodeIds(nodeIds: readonly string[], links: readonly SankeyGraphLink[], parameterId: string, currentFromId: string): string[];
+export declare function sankeyRestoreVisibleIds(parameterIds: readonly string[]): string[];
+export declare function sankeyVisibilityIsSubset(allIds: readonly string[], visible: ReadonlySet<string>): boolean;
+/** Parameter ids on declared links that touch any of `nodeIds`. */
+export declare function sankeyIncidentParameterIds(links: readonly SankeyGraphLink[], nodeIds: readonly string[]): string[];
+export declare function sankeyHeightFloor(height: number | null, compact: boolean): number;
+export declare function formatSankeyNumber(value: number, decimalPlaces: number, units: string): string;

package/dist/src/workspace/reports/sankey/layout.d.ts

@@ -0,0 +1,80 @@
+import { type ReportColor, type ReportParameterSetup, type SankeySetup } from "@overvis/hmi-shared/report";
+import { type ReportSankeyCache } from "./demand.js";
+/**
+ * Sankey geometry shared by the interactive widget and the render HTML. Ribbon thickness and
+ * node height come straight from d3-sankey, so every node is exactly as tall as its flows.
+ */
+export interface SankeyDrawnLink {
+    fromNodeId: string;
+    toNodeId: string;
+    parameterId: string;
+    displayValue: number;
+    color: ReportColor;
+    decimalPlaces: number;
+    units: string;
+    snapshotLabel: string;
+    order: number;
+}
+export interface SankeyDrawnNode {
+    id: string;
+    label: string;
+    order: number;
+}
+export interface SankeyGraph {
+    nodes: SankeyDrawnNode[];
+    links: SankeyDrawnLink[];
+}
+export interface SankeyLaidOutLink {
+    link: SankeyDrawnLink;
+    path: string;
+    strokeWidth: number;
+    /** Where the value label sits on the ribbon; null when every spot collides with a label. */
+    valueLabel: {
+        x: number;
+        y: number;
+    } | null;
+    /** Formatted value with units. */
+    valueText: string;
+}
+export interface SankeyLaidOutNode {
+    node: SankeyDrawnNode;
+    x0: number;
+    x1: number;
+    y0: number;
+    y1: number;
+    /** Labels sit right of the node (free of incoming ribbons); the last column labels left. */
+    labelX: number;
+    labelAnchor: "start" | "end";
+    /** Sum of positive incident flows, formatted for the node tooltip. */
+    title: string;
+}
+export interface SankeyLayout {
+    width: number;
+    height: number;
+    links: SankeyLaidOutLink[];
+    nodes: SankeyLaidOutNode[];
+}
+/** Ribbons stay translucent so labels and crossings read; ≤0 hairlines are drawn opaque. */
+export declare const SANKEY_RIBBON_OPACITY = 0.5;
+export declare function buildSankeyGraph(options: {
+    setup: SankeySetup;
+    parametersById: ReadonlyMap<string, ReportParameterSetup>;
+    visibleParameterIds: ReadonlySet<string>;
+    from: number;
+    closedTo: number;
+    locale: string;
+    cache: ReportSankeyCache;
+}): SankeyGraph;
+/**
+ * A node is as tall as the larger of its positive inflow and outflow (what d3 draws), so the
+ * tooltip reports that throughput, in the links' units when they agree.
+ */
+export declare function sankeyNodeThroughputText(nodeId: string, links: readonly SankeyDrawnLink[]): string;
+export declare function sankeyCanvasHeight(nodeCount: number, heightFloor: number, compact: boolean): number;
+/** `height` is the canvas the caller can spare; it still grows to fit every node row. */
+export declare function layoutSankey(options: {
+    graph: SankeyGraph;
+    width: number;
+    height: number;
+    compact: boolean;
+}): SankeyLayout;

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

@@ -0,0 +1,7 @@
+import { type ReactNode } from "react";
+import type { SankeySetup } from "@overvis/hmi-shared/report";
+export interface SankeyRepresentationProps {
+    setup: SankeySetup;
+    className?: string;
+}
+export declare function SankeyRepresentation({ setup, className }: SankeyRepresentationProps): ReactNode;

package/dist/src/workspace/reports/sankey/use-caches.d.ts

@@ -0,0 +1,16 @@
+import type { ReportCacheEnv } from "../data/report-caches.js";
+import { type DemandRegistration, type DemandRegistry } from "../use-demand-cache.js";
+import { type ReportSankeyCache, type ReportSankeyDemand } from "./demand.js";
+export interface ReportSankeyCaches {
+    sankeyCache: ReportSankeyCache;
+    /** End of the closed aggregate window the cache covers. */
+    sankeyClosedTo: number;
+}
+/**
+ * Sankey weights: `readings.aggregate` over the closed session window. Not a declarative slot: a
+ * window ending now stays pinned to live and re-plans at every UTC minute close.
+ */
+export declare function useReportSankeyCaches(registry: DemandRegistry<ReportSankeyDemand>, range: {
+    from: number;
+    to: number;
+}, env: ReportCacheEnv): ReportSankeyCaches & DemandRegistration<ReportSankeyDemand>;

package/dist/src/workspace/reports/session/init.d.ts

@@ -0,0 +1,9 @@
+import { type ReportPreset } from "@overvis/hmi-shared/report";
+export declare function buildInitialSession(workspaceId: string, preset: ReportPreset, timeZone: string, currentParamIds: string[], fullRangeFromMs: number | null, extentPending: boolean, sessionScope?: string, 
+/** False for a host-owned window: nothing is read from or written to storage. */
+persist?: boolean): {
+    from: number;
+    to: number;
+    visibleParameterIds: string[];
+    usedFullRangeFallback: boolean;
+} | null;

package/dist/src/workspace/reports/session/storage.d.ts

@@ -0,0 +1,24 @@
+export interface ReportSessionStored {
+    from: number;
+    to: number;
+    visibleParameterIds: string[];
+    knownParameterIds?: string[];
+}
+export declare function reportSessionStorageKey(workspaceId: string, reportPresetId: string, sessionScope?: string): string;
+export declare function readReportSession(workspaceId: string, reportPresetId: string, sessionScope?: string): ReportSessionStored | null;
+export declare function writeReportSession(workspaceId: string, reportPresetId: string, session: ReportSessionStored, sessionScope?: string): void;
+/**
+ * When immutable: keep any previously stored from/to; only refresh visibility (+ known).
+ * First open (no stored range) may seed from/to with the resolved default.
+ */
+export declare function writeReportSessionPreservingRange(workspaceId: string, reportPresetId: string, resolvedFrom: number, resolvedTo: number, visibleParameterIds: string[], knownParameterIds: string[], sessionScope?: string): void;
+/**
+ * Merge stored visibility with current preset parameter ids.
+ * Uses `knownParameterIds` when present so intentionally hidden ids stay hidden;
+ * brand-new snapshot ids default to visible. Legacy sessions without `known`
+ * treat prior visible ids as the known set so ∪-new still applies.
+ */
+export declare function mergeVisibleParameterIds(stored: {
+    visibleParameterIds: string[];
+    knownParameterIds?: string[];
+} | null, currentIds: readonly string[]): string[];

package/dist/src/workspace/reports/state-duration/demand.d.ts

@@ -0,0 +1,39 @@
+export interface ReportStateDurationDemandSlot {
+    parameterId: string;
+    sourceValueType: string;
+}
+export interface ReportStateDurationDemand {
+    slots: ReportStateDurationDemandSlot[];
+}
+export interface ReportStateDurationPoint {
+    time: number;
+    value: number | string;
+    repr?: string | null;
+}
+export type ReportStateDurationEntryStatus = "idle" | "loading" | "ready" | "error";
+export interface ReportStateDurationEntry {
+    points: ReportStateDurationPoint[];
+    status: ReportStateDurationEntryStatus;
+    error: string | null;
+    fetchedTo: number;
+    fetchedAt: number;
+}
+export type ReportStateDurationCache = Map<string, ReportStateDurationEntry>;
+export interface ReportStateDurationNeed {
+    key: string;
+    parameterId: string;
+    sourceValueType: string;
+    from: number;
+    to: number;
+}
+export declare function emptyStateDurationEntry(): ReportStateDurationEntry;
+export declare function stateDurationFetchTo(from: number, to: number, nowMs?: number): number;
+/** Cache identity omits live `to` so follow-live ticks do not thrash. */
+export declare function stateDurationCacheKey(parts: {
+    parameterId: string;
+    sourceValueType: string;
+    from: number;
+}): string;
+export declare function serializeReportStateDurationDemand(demand: ReportStateDurationDemand): string;
+export declare function collectStateDurationNeeds(demands: ReadonlyMap<string, ReportStateDurationDemand>, from: number, to: number, nowMs?: number): ReportStateDurationNeed[];
+export declare function stateDurationEntryNeedsFetch(entry: ReportStateDurationEntry | undefined, sessionTo: number, nowMs?: number): boolean;

package/dist/src/workspace/reports/state-duration/reduce.d.ts

@@ -0,0 +1,27 @@
+import type { ReportColor, ReportParameterSetup } from "@overvis/hmi-shared/report";
+export interface StateDurationChangePoint {
+    time: number;
+    value: number | string;
+    repr?: string | null;
+}
+export interface StateDurationSlice {
+    integerValue: number;
+    label: string;
+    color: ReportColor;
+    durationMs: number;
+    percent: number;
+    /** `percent` with exactly one decimal (`3.0`, `59.6`). */
+    percentText: string;
+    durationText: string;
+}
+export declare function stateDurationWindowCanHaveKnownSpan(from: number, to: number, nowMs: number): boolean;
+export declare function formatStateDurationMs(ms: number): string;
+export declare function stateDurationSliceColor(snapshot: ReportParameterSetup, integer: number): ReportColor;
+export declare function reduceStateDurationSlices(options: {
+    points: readonly StateDurationChangePoint[];
+    from: number;
+    to: number;
+    nowMs?: number;
+    snapshot: ReportParameterSetup;
+    locale: string;
+}): StateDurationSlice[];

package/dist/src/workspace/reports/state-duration/representation.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from "react";
+import type { StateDurationSetup } from "@overvis/hmi-shared/report";
+export interface StateDurationRepresentationProps {
+    setup: StateDurationSetup;
+    className?: string;
+}
+export declare function StateDurationRepresentation({ setup, className, }: StateDurationRepresentationProps): ReactNode;

package/dist/src/workspace/reports/state-duration/use-caches.d.ts

@@ -0,0 +1,15 @@
+import { type DemandRegistration, type DemandRegistry } from "../use-demand-cache.js";
+import { type ReportStateDurationCache, type ReportStateDurationDemand } from "./demand.js";
+import type { ReportReadingsEnv } from "../readings-client.js";
+export interface ReportStateDurationCaches {
+    stateDurationCache: ReportStateDurationCache;
+}
+/**
+ * Change points up to the session end. Not a declarative slot: the window end is read at run time,
+ * so live `to` ticks do not re-plan. A run starts on demand or `from` changes, when `to` moves
+ * back, and when a live window's entries go stale.
+ */
+export declare function useReportStateDurationCaches(registry: DemandRegistry<ReportStateDurationDemand>, range: {
+    from: number;
+    to: number;
+}, env: ReportReadingsEnv<"changePoints">): ReportStateDurationCaches & DemandRegistration<ReportStateDurationDemand>;

package/dist/src/workspace/reports/table/cache-fetch.d.ts

@@ -0,0 +1,8 @@
+import type { ReportReadingsEnv } from "../readings-client.js";
+import { type DemandFetchContext } from "../demand-cache.js";
+import { type ReportTableAggregateEntry, type ReportTableRawEntry } from "./demand.js";
+import { type AggregateNeed, type RawNeed } from "./fetch.js";
+/** Precise rows: `readings.raw` pages per series, resuming after the seeded points. */
+export declare function fetchRawSeries(needs: RawNeed[], context: DemandFetchContext<ReportTableRawEntry>, { workspaceId, readings }: ReportReadingsEnv<"raw">): Promise<void>;
+/** Footer/subtotal aggregates. A refetch keeps the previous value until the new one lands. */
+export declare function fetchTableAggregates(needs: AggregateNeed[], context: DemandFetchContext<ReportTableAggregateEntry>, env: ReportReadingsEnv<"aggregate">): Promise<void>;

package/dist/src/workspace/reports/table/chunk.d.ts

@@ -0,0 +1,31 @@
+import { type ReadingsCadence } from "@overvis/hmi-shared/parameter";
+import { type TableSetup } from "@overvis/hmi-shared/report";
+export interface TimeWindow {
+    from: number;
+    to: number;
+}
+export declare function reportYmd(parts: {
+    year: number;
+    month: number;
+    day: number;
+}): string;
+/** Exclusive `to` of the last fully closed display bucket (`precise` keeps `to`). */
+export declare function lastClosedTableTo(from: number, to: number, rowCadenceMs: TableSetup["rowCadenceMs"], timeZone: string): number;
+export declare function addLocalHours(ms: number, deltaHours: number, timeZone: string): number | null;
+/** Exclusive end of the display bucket that starts at `rowTime` (precise returns `rowTime`). */
+export declare function nextTableBodyBucketEnd(rowTime: number, rowCadenceMs: TableSetup["rowCadenceMs"], timeZone: string): number | null;
+/**
+ * Cadence body cells use half-open `[rowTime, next)`. A point comment (`from === to`) sits in
+ * that bucket; a range whose `to` equals `next` does not mark the next row. Precise cells match
+ * an inclusive comment range at the row timestamp.
+ */
+export declare function tableCommentOverlapsBodyCell(commentFrom: number, commentTo: number, rowTime: number, rowCadenceMs: TableSetup["rowCadenceMs"], timeZone: string): boolean;
+/** First display-bucket start that fully sits in `[from, exclusiveTo)`. */
+export declare function firstFullySittingBucketStart(from: number, exclusiveTo: number, rowCadenceMs: Exclude<TableSetup["rowCadenceMs"], "precise">, timeZone: string): number | null;
+/**
+ * Exclusive-end window for `readings.aggregate` matching body coverage.
+ * Precise uses `[from, to]` inclusive via exclusive `to + 1`.
+ */
+export declare function tableAggregateWindow(from: number, to: number, rowCadenceMs: TableSetup["rowCadenceMs"], timeZone: string): TimeWindow | null;
+/** Split `[from, to)` so each chunk’s estimated closed buckets stay ≤ 20k. */
+export declare function chunkCadenceWindow(from: number, to: number, cadence: ReadingsCadence, timeZone: string): TimeWindow[];

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

@@ -0,0 +1,83 @@
+import type { ReadingsDiscreteAggregation, ReadingsNumericAggregation } from "@overvis/hmi-shared/parameter";
+import type { TableSetup } from "@overvis/hmi-shared/report";
+export type TableCadenceAggregation = ReadingsNumericAggregation | ReadingsDiscreteAggregation;
+export interface ReportTableDemandColumn {
+    parameterId: string;
+    sourceValueType: string;
+    snapshotType: "numeric" | "integer" | "string";
+    /** Cadence aggregation for body cells (int/str always `latest`). */
+    aggregation: TableCadenceAggregation;
+    totals: string;
+}
+export interface ReportTableDemand {
+    columns: ReportTableDemandColumn[];
+    rowCadenceMs: TableSetup["rowCadenceMs"];
+    subtotals: TableSetup["subtotals"];
+}
+export interface ReportTablePoint {
+    time: number;
+    value: number | string;
+    repr?: string | null;
+}
+export interface ReportTableCadenceValue {
+    bucketStart: number;
+    value: number | string;
+    repr?: string | null;
+}
+export interface ReportTableCadenceEntry {
+    rows: ReportTableCadenceValue[];
+    status: "idle" | "loading" | "ready" | "error";
+    error: string | null;
+    loadingMore: boolean;
+    /** Exclusive end of the last successfully fetched cadence chunk. */
+    fetchedTo: number;
+}
+export interface ReportTableRawEntry {
+    points: ReportTablePoint[];
+    status: "idle" | "loading" | "ready" | "error";
+    error: string | null;
+    loadingMore: boolean;
+}
+export interface ReportTableAggregateEntry {
+    value: number | string | null;
+    repr?: string | null;
+    status: "idle" | "loading" | "ready" | "error";
+    error: string | null;
+}
+export type ReportTableCadenceCache = Map<string, ReportTableCadenceEntry>;
+export type ReportTableRawCache = Map<string, ReportTableRawEntry>;
+export type ReportTableAggregateCache = Map<string, ReportTableAggregateEntry>;
+export declare function emptyTableCadenceEntry(): ReportTableCadenceEntry;
+/**
+ * Fetch missing, idle, failed, interrupted, or still-paging entries (cadence chunks, raw pages). A
+ * new run aborts the previous one, so `loading` or `loadingMore` belongs to a cancelled request.
+ */
+export declare function pagedEntryNeedsFetch(entry: {
+    status: string;
+    loadingMore: boolean;
+} | undefined): boolean;
+export declare function emptyTableRawEntry(): ReportTableRawEntry;
+export declare function tableCadenceCacheKey(parts: {
+    parameterId: string;
+    sourceValueType: string;
+    aggregation: string;
+    cadence: string;
+    timeZone: string;
+    from: number;
+    to: number;
+}): string;
+export declare function tableRawCacheKey(parts: {
+    parameterId: string;
+    sourceValueType: string;
+    from: number;
+    to: number;
+}): string;
+export declare function tableAggregateCacheKey(parts: {
+    parameterId: string;
+    sourceValueType: string;
+    aggregation: string;
+    from: number;
+    to: number;
+}): string;
+export declare function serializeReportTableDemand(demand: ReportTableDemand): string;
+export declare function bodyAggregationForColumn(column: Pick<ReportTableDemandColumn, "snapshotType" | "aggregation">, rowCadenceMs: TableSetup["rowCadenceMs"]): TableCadenceAggregation;

package/dist/src/workspace/reports/table/fetch.d.ts

@@ -0,0 +1,42 @@
+import type { ReadingsCadence, ReadingsCadenceParameter } from "@overvis/hmi-shared/parameter";
+import { type TimeWindow } from "./chunk.js";
+import { type ReportTableDemand } from "./demand.js";
+/** Parameters per readings request: the readings input schemas' `maxItems`. */
+export declare const READINGS_HTTP_PARAM_BATCH = 100;
+export declare const RAW_PAGE_MAX_POINTS = 10000;
+export interface CadenceNeed {
+    key: string;
+    parameterId: string;
+    sourceValueType: string;
+    aggregation: ReadingsCadenceParameter["aggregation"];
+    cadence: ReadingsCadence;
+    timeZone: string;
+    from: number;
+    to: number;
+}
+export interface RawNeed {
+    key: string;
+    parameterId: string;
+    sourceValueType: string;
+    from: number;
+    to: number;
+}
+export interface AggregateNeed {
+    key: string;
+    parameterId: string;
+    sourceValueType: string;
+    aggregation: ReadingsCadenceParameter["aggregation"];
+    from: number;
+    to: number;
+}
+export declare function sliceParameterBatches<T>(items: readonly T[], size?: number): T[][];
+export declare function nextRawCursor(points: readonly {
+    time: number;
+}[], windowFrom: number): number;
+export declare function firstUnfetchedChunkIndex(chunks: readonly TimeWindow[], fetchedTo: number): number;
+export declare function isAbortError(error: unknown): boolean;
+export declare function collectNeeds(demands: ReadonlyMap<string, ReportTableDemand>, from: number, to: number, timeZone: string): {
+    cadence: CadenceNeed[];
+    raw: RawNeed[];
+    aggregate: AggregateNeed[];
+};

package/dist/src/workspace/reports/table/format.d.ts

@@ -0,0 +1,7 @@
+import { type ReportParameterSetup, type TableParameterSetup, type TableSetup } from "@overvis/hmi-shared/report";
+import { type ReportColorPalette } from "../chart/colors.js";
+import type { TableBodyCell } from "./rows.js";
+export declare function formatTableCellText(cell: TableBodyCell, column: TableParameterSetup, locale: string): string;
+/** Body rows stay `YYYY-MM-DD HH:mm:ss`; day subtotals are the date, hour subtotals drop seconds. */
+export declare function formatTableTimeCell(time: number, timeZone: string, kind: "body" | "subtotal", subtotals: TableSetup["subtotals"]): string;
+export declare function tableCellBackground(cell: TableBodyCell, column: TableParameterSetup, snapshot: ReportParameterSetup, palette?: ReportColorPalette): string | undefined;

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

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+import { type TableSetup } from "@overvis/hmi-shared/report";
+export interface TableRepresentationProps {
+    setup: TableSetup;
+    className?: string;
+}
+/**
+ * Runtime table representation. Registers visible-column demand with ReportDataProvider.
+ */
+export declare function TableRepresentation({ setup, className }: TableRepresentationProps): ReactNode;

package/dist/src/workspace/reports/table/rows.d.ts

@@ -0,0 +1,31 @@
+import { type TableSetup } from "@overvis/hmi-shared/report";
+import type { ReportTableCadenceValue, ReportTablePoint } from "./demand.js";
+export interface TableBodyCell {
+    value: number | string | null;
+    repr?: string | null;
+}
+/** Kind + timestamp for a painted row; cells are looked up on demand. */
+export interface TableRowRef {
+    kind: "body" | "subtotal";
+    time: number;
+}
+export declare function unionSortedMapKeys<V>(maps: readonly Map<number, V>[]): number[];
+export declare function pointsByTime(points: readonly ReportTablePoint[]): Map<number, TableBodyCell>;
+export declare function cadenceByBucket(rows: readonly ReportTableCadenceValue[]): Map<number, TableBodyCell>;
+export declare function localGroupStartMs(time: number, grain: "per-day" | "per-hour", timeZone: string): number;
+export declare function localGroupEndMs(groupStart: number, grain: "per-day" | "per-hour", timeZone: string): number;
+export interface LeadingClippedSubtotalWindow {
+    groupStart: number;
+    from: number;
+    to: number;
+}
+/**
+ * When the report window starts mid-group, a 1d/1h cadence bucket for that
+ * group is either missing or would include samples before `from`. Use
+ * `readings.aggregate` over the closed body intersection instead.
+ */
+export declare function leadingClippedSubtotalWindow(from: number, closedTo: number, grain: "per-day" | "per-hour", rowCadenceMs: TableSetup["rowCadenceMs"], timeZone: string): LeadingClippedSubtotalWindow | null;
+export declare function insertSubtotalRefs(times: readonly number[], grain: "per-day" | "per-hour", timeZone: string, options: {
+    closedTo: number;
+    bodyComplete: boolean;
+}): TableRowRef[];